@stll/folio-core 0.47.7 → 0.49.0

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

@@ -1,15 +1,18 @@
 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 { resolveFloatingTablePageX } from "./floatingTablePosition.js";
+import { getHyphenationDictionaryMisses } from "./hyphenationDictionaries.js";
 import { findClearLineY, measureParagraph } from "./measureParagraph.js";
+import { buildTableCellFloatingZones, getTableCellFloatingImages } from "./tableCellFloating.js";
 import { createTableCellFlowState, finishTableCellFlow, placeTableCellBlock } from "./tableCellFlow.js";
-import { buildTableCellGrid, getFirstAvailableColumn, getTableCellVerticalBorderHeight } from "./tableCellGrid.js";
+import { buildTableCellGrid, getFirstAvailableColumn, getTableCellSpacingInsetsX, getTableCellSpacingInsetsY, getTableCellVerticalBorderHeight } from "./tableCellGrid.js";
 import { layoutTextBoxContent } from "./textBoxParagraphLayout.js";
 //#region src/layout-engine/measure/measureBlocks.ts
 /**
@@ -59,6 +62,27 @@ function emuToPixels(emu) {
 	if (emu === void 0) return 0;
 	return Math.round(emu * 96 / 914400);
 }
+/**
+* Re-measure a cell's paragraphs against the wrap exclusions of the pictures
+* anchored in it, so lines a picture displaces (beside it, or below it when it
+* leaves no room) count toward the cell height. Mirrors the painter's
+* per-paragraph re-measure so both agree on where each line sits.
+*/
+function wrapTableCellParagraphsAroundFloats(cell, cellMeasure, contentWidth, fieldValues) {
+	const zones = buildTableCellFloatingZones(getTableCellFloatingImages(cell, cellMeasure, contentWidth), contentWidth);
+	if (zones.length === 0) return;
+	const flowState = createTableCellFlowState();
+	for (let blockIdx = 0; blockIdx < cell.blocks.length; blockIdx++) {
+		const block = cell.blocks[blockIdx];
+		let blockMeasure = cellMeasure.blocks[blockIdx];
+		if (!block || !blockMeasure) continue;
+		if (block.kind === "paragraph") {
+			blockMeasure = measureBlock(block, contentWidth, zones, placeTableCellBlock({ ...flowState }, block, blockMeasure).contentTop, fieldValues);
+			cellMeasure.blocks[blockIdx] = blockMeasure;
+		}
+		placeTableCellBlock(flowState, block, blockMeasure);
+	}
+}
 function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 	let columnWidths = tableBlock.columnWidths ?? [];
 	const explicitWidthPx = resolveTableWidthPx(tableBlock.width, tableBlock.widthType, contentWidth);
@@ -74,24 +98,32 @@ 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;
 	const columnsPinned = tableColumnsArePinned(tableBlock);
 	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;
 				if (cellWidth === 0) cellWidth = cell.width ?? 100;
+				const spacingInsets = getTableCellSpacingInsetsX(cellSpacing, columnIndex, colSpan, columnWidths.length);
+				cellWidth = Math.max(0, cellWidth - spacingInsets.start - spacingInsets.end);
 				columnIndex = getFirstAvailableColumn(cellGrid, rowIdx, columnIndex + colSpan);
 				const { left: padLeft, right: padRight } = resolveTableCellPadding(cell);
 				const cellContentWidth = Math.max(1, cellWidth - padLeft - padRight);
-				const measureWidth = cell.noWrap === true && !columnsPinned ? NO_WRAP_MEASURE_WIDTH : cellContentWidth;
+				const keepSingleLine = cell.noWrap === true && !columnsPinned;
+				const measureWidth = keepSingleLine ? NO_WRAP_MEASURE_WIDTH : cellContentWidth;
 				const cellMeasure = {
 					blocks: cell.blocks.map((b) => measureBlock(b, measureWidth, void 0, void 0, fieldValues)),
 					width: cellWidth,
 					height: 0
 				};
+				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;
@@ -111,7 +143,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++) {
@@ -129,15 +161,17 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			const { top: padTop, bottom: padBottom } = resolveTableCellPadding(sourceCell);
 			cell.height += padTop + padBottom;
 			if ((sourceCell?.rowSpan ?? 1) > 1) continue;
-			const borderHeight = getTableCellVerticalBorderHeight(cellGrid, sourceCell, rowIdx);
+			const borderHeight = getTableCellVerticalBorderHeight(cellGrid, sourceCell, rowIdx, bordersSeparated);
 			maxCellHeightWithBorders = Math.max(maxCellHeightWithBorders, cell.height + borderHeight);
 			maxCellInsets = Math.max(maxCellInsets, padTop + padBottom + borderHeight);
 		}
 		const explicitHeight = sourceRow?.height;
 		const heightRule = sourceRow?.heightRule;
-		if (explicitHeight && heightRule === "exact") row.height = explicitHeight;
-		else if (explicitHeight) row.height = Math.max(maxCellHeightWithBorders, explicitHeight + maxCellInsets);
-		else row.height = maxCellHeightWithBorders;
+		const spacing = getTableCellSpacingInsetsY(cellSpacing, rowIdx, 1, rowCount);
+		const spacingHeight = spacing.top + spacing.bottom;
+		if (explicitHeight && heightRule === "exact") row.height = (bordersSeparated ? Math.max(0, explicitHeight - (cellSpacing ?? 0)) : explicitHeight) + spacingHeight;
+		else if (explicitHeight) row.height = Math.max(maxCellHeightWithBorders, explicitHeight + maxCellInsets) + spacingHeight;
+		else row.height = maxCellHeightWithBorders + spacingHeight;
 	}
 	for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
 		const sourceRow = tableBlock.rows[rowIdx];
@@ -151,7 +185,8 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			const spanEnd = Math.min(rows.length, rowIdx + rowSpan);
 			let combinedHeight = 0;
 			for (let spannedRowIdx = rowIdx; spannedRowIdx < spanEnd; spannedRowIdx++) combinedHeight += rows[spannedRowIdx]?.height ?? 0;
-			const deficit = measuredCell.height + getTableCellVerticalBorderHeight(cellGrid, sourceCell, rowIdx) - combinedHeight;
+			const spanSpacing = getTableCellSpacingInsetsY(cellSpacing, rowIdx, rowSpan, rowCount);
+			const deficit = measuredCell.height + getTableCellVerticalBorderHeight(cellGrid, sourceCell, rowIdx, bordersSeparated) + spanSpacing.top + spanSpacing.bottom - combinedHeight;
 			if (deficit <= 0) continue;
 			for (let spannedRowIdx = spanEnd - 1; spannedRowIdx >= rowIdx; spannedRowIdx--) {
 				if (tableBlock.rows[spannedRowIdx]?.heightRule === "exact") continue;
@@ -529,8 +564,9 @@ function measureBlock(block, contentWidth, floatingZones, cumulativeY, fieldValu
 			if (floatingZones) measureOpts.floatingZones = floatingZones;
 			if (fieldValues) measureOpts.fieldValues = fieldValues;
 			if (options?.allowEndTabOverflow === true) measureOpts.allowEndTabOverflow = true;
+			const missesBefore = getHyphenationDictionaryMisses();
 			const result = measureParagraph(pBlock, contentWidth, measureOpts);
-			if (cacheable) setCachedParagraphMeasure(pBlock, contentWidth, result);
+			if (cacheable && getHyphenationDictionaryMisses() === missesBefore) setCachedParagraphMeasure(pBlock, contentWidth, result);
 			return result;
 		}
 		case "table": return measureTableBlock(block, contentWidth, fieldValues);

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

@@ -1,11 +1,12 @@
 import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
-import { SCRIPT_CLASS, hasCjk, hasComplexScript, scriptClassOf, segmentByScript } from "../../utils/scriptSegments.js";
+import { SCRIPT_CLASS, hasComplexScript, hasEastAsiaSlotText, scriptClassOf, segmentByScript } from "../../utils/scriptSegments.js";
 import { getCachedFontMetrics, getCachedTextWidth, getTextWidthCacheGeneration, setCachedFontMetrics, setCachedTextWidth } from "./cache.js";
 import { applyComplexScriptFormatting, hasComplexScriptFormatting } from "./complexScriptFormatting.js";
 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
@@ -70,7 +71,7 @@ function getWorkerFontFingerprintWidth(ctx, font, fontCacheKey, fontKerning) {
 */
 function canvasGetFontMetrics(style) {
 	const fontSize = style.fontSize ?? 11;
-	const fontFamily = style.fontFamily ?? "Calibri";
+	const fontFamily = style.fontFamily ?? "Times New Roman";
 	const bold = style.bold ?? false;
 	const italic = style.italic ?? false;
 	const fontVariant = style.fontVariant;
@@ -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);
@@ -197,7 +199,7 @@ function glyphAdvanceStyle(style) {
 * AND text that would select it. Keeps the all-Latin path on a single font.
 */
 function needsPerScriptFonts(style, measuredText) {
-	if (style.eastAsiaFontFamily && hasCjk(measuredText)) return true;
+	if (style.eastAsiaFontFamily && hasEastAsiaSlotText(measuredText, style.eastAsiaHint)) return true;
 	return hasComplexScriptFormatting(style) && hasComplexScript(measuredText);
 }
 /** Resolve the independent font/style slot selected by a script segment. */
@@ -219,7 +221,39 @@ function measureMixedScriptWidth(measuredText, style) {
 	const letterSpacing = style.letterSpacing ?? 0;
 	const horizontalScale = getHorizontalScaleFactor(style.horizontalScale);
 	let glyphWidth = 0;
-	for (const segment of segmentByScript(measuredText)) glyphWidth += canvasMeasureTextWidth(segment.text, glyphAdvanceStyle(scriptStyle(style, segment.script)));
+	for (const segment of segmentByScript(measuredText, style.eastAsiaHint)) glyphWidth += canvasMeasureTextWidth(segment.text, glyphAdvanceStyle(scriptStyle(style, segment.script)));
+	let width = glyphWidth;
+	if (letterSpacing) {
+		const codePoints = countCodePoints(measuredText);
+		if (codePoints > 1) width += letterSpacing * (codePoints - 1);
+	}
+	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);
@@ -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 script = scriptClassOf(cp);
+		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.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,34 @@ 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;
+}
+/**
+* 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,
@@ -28,13 +55,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 } : {},
@@ -45,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
 	};
@@ -103,11 +130,10 @@ 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`);
-	const fontFamily = style.fontFamily ?? "Calibri";
+	const fontFamily = style.fontFamily ?? "Times New Roman";
 	parts.push(getResolvedFallback(fontFamily, style.alternateFontFamily));
 	return parts.join(" ");
 }
@@ -181,4 +207,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 };