@stll/folio-core 0.28.1 → 0.30.0

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

@@ -3,12 +3,27 @@ import { FloatingImageZone } from "./floatingZones.js";
 import "./measureParagraph.js";
 //#region src/layout-engine/measure/measureBlocks.d.ts
 declare function measureTableBlock(tableBlock: TableBlock, contentWidth: number, fieldValues?: ReadonlyMap<number, string>): TableMeasure;
+type PhysicalBandPageGeometry = {
+  pageWidth: number | number[];
+  pageHeight: number | number[];
+  marginTop: number | number[];
+  marginLeft: number | number[];
+  marginRight: number | number[];
+  marginBottom: number | number[];
+};
 type BandPageGeometry = {
   pageWidth?: number | number[];
   pageHeight: number | number[];
   marginLeft?: number | number[];
   marginRight?: number | number[];
   marginBottom: number | number[];
+  /** Absolute page X of each block's active column origin. */
+  contentLeft?: number | number[];
+  physicalPage?: PhysicalBandPageGeometry;
+  /** Authored flow-column index occupied by each block. */
+  columnIndex?: number | number[];
+  /** Authored flow-column count for each block's section. */
+  columnCount?: number | number[];
 };
 /**
  * Measure a block based on its type.

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

@@ -1,10 +1,12 @@
+import { hasPageBreakBefore } from "../keep-together.js";
 import { recordMeasureBlock, recordMeasureBlockError } from "../layoutInstrumentation.js";
 import { isParagraphFrameTextBox } from "../paragraphFrame.js";
+import { normalizeSectionBreakType } from "../section-breaks.js";
 import { bandFragmentX, bandTopContentY, isPageFrameRelativeAnchor } from "../textBoxFlow.js";
 import { getTextBoxGroupId } from "../textBoxGroup.js";
 import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, floatingTextBoxWrapsText, resolveTableCellPadding, tableColumnsArePinned } from "../types.js";
 import { getCachedParagraphMeasure, setCachedParagraphMeasure } from "./cache.js";
-import { resolveFloatingTableX } from "./floatingTablePosition.js";
+import { resolveFloatingTablePageX } from "./floatingTablePosition.js";
 import { findClearLineY, measureParagraph } from "./measureParagraph.js";
 import { createTableCellFlowState, finishTableCellFlow, placeTableCellBlock } from "./tableCellFlow.js";
 import { buildTableCellGrid, getFirstAvailableColumn, getTableCellVerticalBorderHeight } from "./tableCellGrid.js";
@@ -177,6 +179,42 @@ function perBlockNumberValue(value, blockIndex, fallback) {
 	if (Array.isArray(value)) return value[blockIndex] ?? fallback;
 	return value;
 }
+function resolveFloatingTableVerticalPosition({ floating, tableHeight, pageHeight, marginTop, marginBottom, distTop, distBottom }) {
+	let offset = floating.tblpY;
+	if (offset === void 0) {
+		const contentHeight = Math.max(0, pageHeight - marginTop - marginBottom);
+		switch (floating.tblpYSpec) {
+			case "top":
+				offset = 0;
+				break;
+			case "center":
+				offset = (contentHeight - tableHeight) / 2;
+				break;
+			case "bottom":
+				offset = contentHeight - tableHeight;
+				break;
+			case "inside":
+			case "outside":
+			case "inline":
+			case void 0: break;
+			default: floating.tblpYSpec;
+		}
+	}
+	if (offset === void 0 || floating.vertAnchor === "text") {
+		const anchorOffset = offset ?? 0;
+		return {
+			type: "anchorRelative",
+			topOffset: anchorOffset - distTop,
+			bottomOffset: anchorOffset + tableHeight + distBottom
+		};
+	}
+	const frameTop = floating.vertAnchor === "page" ? 0 : marginTop;
+	return {
+		type: "pageRelative",
+		pageTop: frameTop + offset - distTop,
+		pageBottom: frameTop + offset + tableHeight + distBottom
+	};
+}
 function textBoxWrapSide({ box, contentX, boxWidth, contentWidth }) {
 	if (box.wrapText === "left") return "left";
 	if (box.wrapText === "right") return "right";
@@ -187,6 +225,7 @@ function textBoxWrapSide({ box, contentX, boxWidth, contentWidth }) {
 }
 function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry) {
 	const zones = [];
+	const tablePageRects = [];
 	const defaultContentWidth = Array.isArray(contentWidth) ? contentWidth[0] ?? 0 : contentWidth;
 	const textBoxGroupAnchors = /* @__PURE__ */ new Map();
 	const paragraphFrameGroupSizes = /* @__PURE__ */ new Map();
@@ -201,11 +240,25 @@ function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry)
 	const marginLeftInput = pageGeometry?.marginLeft ?? 0;
 	const marginRightInput = pageGeometry?.marginRight ?? 0;
 	const marginBottomInput = pageGeometry?.marginBottom ?? 0;
+	const contentLeftInput = pageGeometry?.contentLeft ?? marginLeftInput;
+	const physicalPageWidthInput = pageGeometry?.physicalPage?.pageWidth ?? pageWidthInput;
+	const physicalPageHeightInput = pageGeometry?.physicalPage?.pageHeight ?? pageHeightInput;
+	const physicalMarginTopInput = pageGeometry?.physicalPage?.marginTop ?? marginTop;
+	const physicalMarginLeftInput = pageGeometry?.physicalPage?.marginLeft ?? marginLeftInput;
+	const physicalMarginRightInput = pageGeometry?.physicalPage?.marginRight ?? marginRightInput;
+	const physicalMarginBottomInput = pageGeometry?.physicalPage?.marginBottom ?? marginBottomInput;
 	const defaultPageWidth = Array.isArray(pageWidthInput) ? pageWidthInput[0] ?? defaultContentWidth : pageWidthInput;
 	const defaultPageHeight = Array.isArray(pageHeightInput) ? pageHeightInput[0] ?? 0 : pageHeightInput;
 	const defaultMarginLeft = Array.isArray(marginLeftInput) ? marginLeftInput[0] ?? 0 : marginLeftInput;
 	const defaultMarginRight = Array.isArray(marginRightInput) ? marginRightInput[0] ?? 0 : marginRightInput;
 	const defaultMarginBottom = Array.isArray(marginBottomInput) ? marginBottomInput[0] ?? 0 : marginBottomInput;
+	const defaultContentLeft = Array.isArray(contentLeftInput) ? contentLeftInput[0] ?? defaultMarginLeft : contentLeftInput;
+	const defaultPhysicalPageWidth = Array.isArray(physicalPageWidthInput) ? physicalPageWidthInput[0] ?? defaultPageWidth : physicalPageWidthInput;
+	const defaultPhysicalPageHeight = Array.isArray(physicalPageHeightInput) ? physicalPageHeightInput[0] ?? defaultPageHeight : physicalPageHeightInput;
+	const defaultPhysicalMarginTop = Array.isArray(physicalMarginTopInput) ? physicalMarginTopInput[0] ?? defaultMarginTop : physicalMarginTopInput;
+	const defaultPhysicalMarginLeft = Array.isArray(physicalMarginLeftInput) ? physicalMarginLeftInput[0] ?? defaultMarginLeft : physicalMarginLeftInput;
+	const defaultPhysicalMarginRight = Array.isArray(physicalMarginRightInput) ? physicalMarginRightInput[0] ?? defaultMarginRight : physicalMarginRightInput;
+	const defaultPhysicalMarginBottom = Array.isArray(physicalMarginBottomInput) ? physicalMarginBottomInput[0] ?? defaultMarginBottom : physicalMarginBottomInput;
 	for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
 		const block = blocks[blockIndex];
 		if (block.kind !== "paragraph") continue;
@@ -281,25 +334,43 @@ function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry)
 		const tableBlock = block;
 		const floating = tableBlock.floating;
 		if (!floating) continue;
-		const tableMeasure = measureTableBlock(tableBlock, defaultContentWidth);
+		const blockPageWidth = perBlockNumberValue(physicalPageWidthInput, blockIndex, defaultPhysicalPageWidth);
+		const blockPageHeight = perBlockNumberValue(physicalPageHeightInput, blockIndex, defaultPhysicalPageHeight);
+		const blockContentTop = perBlockNumberValue(physicalMarginTopInput, blockIndex, defaultPhysicalMarginTop);
+		const blockMarginLeft = perBlockNumberValue(physicalMarginLeftInput, blockIndex, defaultPhysicalMarginLeft);
+		const blockMarginRight = perBlockNumberValue(physicalMarginRightInput, blockIndex, defaultPhysicalMarginRight);
+		const blockMarginBottom = perBlockNumberValue(physicalMarginBottomInput, blockIndex, defaultPhysicalMarginBottom);
+		const blockContentWidth = perBlockNumberValue(contentWidth, blockIndex, defaultContentWidth);
+		const blockContentLeft = perBlockNumberValue(contentLeftInput, blockIndex, defaultContentLeft);
+		const tableMeasure = measureTableBlock(tableBlock, blockContentWidth);
 		const tableWidth = tableMeasure.totalWidth;
 		const tableHeight = tableMeasure.totalHeight;
 		const distLeft = floating.leftFromText ?? 12;
 		const distRight = floating.rightFromText ?? 12;
 		const distTop = floating.topFromText ?? 0;
 		const distBottom = floating.bottomFromText ?? 0;
-		let leftMargin = 0;
-		let rightMargin = 0;
-		const x = resolveFloatingTableX(floating, tableBlock.justification, tableWidth, defaultContentWidth);
-		if (x < defaultContentWidth / 2) leftMargin = x + tableWidth + distRight;
-		else rightMargin = defaultContentWidth - x + distLeft;
-		const topY = floating.tblpY ?? 0;
-		const bottomY = topY + tableHeight;
-		zones.push({
-			leftMargin,
-			rightMargin,
-			topY: topY - distTop,
-			bottomY: bottomY + distBottom,
+		const pageX = resolveFloatingTablePageX({
+			anchor: floating,
+			justification: tableBlock.justification,
+			tableWidth,
+			marginWidth: blockPageWidth - blockMarginLeft - blockMarginRight,
+			pageWidth: blockPageWidth,
+			marginLeft: blockMarginLeft,
+			textFrameWidth: blockContentWidth,
+			textFrameLeft: blockContentLeft
+		});
+		tablePageRects.push({
+			pageLeft: pageX - distLeft,
+			pageRight: pageX + tableWidth + distRight,
+			vertical: resolveFloatingTableVerticalPosition({
+				floating,
+				tableHeight,
+				pageHeight: blockPageHeight,
+				marginTop: blockContentTop,
+				marginBottom: blockMarginBottom,
+				distTop,
+				distBottom
+			}),
 			anchorBlockIndex: blockIndex
 		});
 	}
@@ -393,7 +464,56 @@ function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry)
 			fullWidthBlock: true
 		});
 	}
-	return zones;
+	return [...zones.map((zone) => ({
+		type: "contentZone",
+		zone
+	})), ...tablePageRects.map((rect) => ({
+		type: "tablePageRect",
+		rect
+	}))];
+}
+function projectFloatingTablePageRect({ rect, contentLeft, contentTop, contentWidth }) {
+	const rectLeft = rect.pageLeft - contentLeft;
+	const rectRight = rect.pageRight - contentLeft;
+	const topY = rect.pageTop - contentTop;
+	const bottomY = rect.pageBottom - contentTop;
+	if (rectRight <= 0 || rectLeft >= contentWidth) return {
+		leftMargin: 0,
+		rightMargin: 0,
+		topY,
+		bottomY
+	};
+	if (rectLeft < contentWidth / 2) return {
+		leftMargin: Math.max(0, Math.min(rectRight, contentWidth)),
+		rightMargin: 0,
+		topY,
+		bottomY
+	};
+	return {
+		leftMargin: 0,
+		rightMargin: Math.max(0, Math.min(contentWidth - rectLeft, contentWidth)),
+		topY,
+		bottomY
+	};
+}
+function activateFloatingTablePageRect(template, anchorPageY) {
+	switch (template.vertical.type) {
+		case "anchorRelative": return {
+			pageLeft: template.pageLeft,
+			pageRight: template.pageRight,
+			pageTop: anchorPageY + template.vertical.topOffset,
+			pageBottom: anchorPageY + template.vertical.bottomOffset
+		};
+		case "pageRelative": return {
+			pageLeft: template.pageLeft,
+			pageRight: template.pageRight,
+			pageTop: template.vertical.pageTop,
+			pageBottom: template.vertical.pageBottom
+		};
+		default:
+			template.vertical;
+			return template.vertical;
+	}
 }
 /**
 * Measure a block based on its type.
@@ -471,16 +591,11 @@ function measureTextBoxBlock(tb, fieldValues) {
 		innerMeasures
 	};
 }
-/**
-* `true` for a section break that explicitly starts a new page
-* (`nextPage`/`evenPage`/`oddPage`). An absent type follows
-* `scheduleSectionBreak` and stays continuous, so measurement must retain any
-* active exclusion zones across it. Used by `measureBlocks` to reset the
-* running Y for a page-pinned band that lands right after the break.
-* eigenpal #694.
-*/
 function isNextPageSectionBreak(block) {
-	return block.kind === "sectionBreak" && block.type !== void 0 && block.type !== "continuous";
+	return block.kind === "sectionBreak" && normalizeSectionBreakType(block.type) !== "continuous";
+}
+function isContinuousSectionBreak(block) {
+	return block.kind === "sectionBreak" && normalizeSectionBreakType(block.type) === "continuous";
 }
 /**
 * Measure all blocks with floating image support.
@@ -491,7 +606,18 @@ function isNextPageSectionBreak(block) {
 */
 function measureBlocks(blocks, contentWidth, marginTop = 0, pageGeometry, fieldValues) {
 	const defaultWidth = Array.isArray(contentWidth) ? contentWidth[0] ?? 0 : contentWidth;
-	const floatingZonesWithAnchors = extractFloatingZones(blocks, contentWidth, marginTop, pageGeometry);
+	const extractedZones = extractFloatingZones(blocks, contentWidth, marginTop, pageGeometry);
+	const floatingZonesWithAnchors = [];
+	const tablePageRects = [];
+	for (const extracted of extractedZones) switch (extracted.type) {
+		case "contentZone":
+			floatingZonesWithAnchors.push(extracted.zone);
+			break;
+		case "tablePageRect":
+			tablePageRects.push(extracted.rect);
+			break;
+		default:
+	}
 	const marginRelative = floatingZonesWithAnchors.filter((z) => z.isMarginRelative && !z.fullWidthBlock);
 	const ownAnchorZones = floatingZonesWithAnchors.filter((z) => !z.isMarginRelative || z.fullWidthBlock);
 	const marginByTopY = /* @__PURE__ */ new Map();
@@ -515,24 +641,59 @@ function measureBlocks(blocks, contentWidth, marginTop = 0, pageGeometry, fieldV
 		existing.push(zone);
 		zonesByAnchor.set(z.anchorBlockIndex, existing);
 	}
-	const anchorIndices = new Set(zonesByAnchor.keys());
+	const tableRectsByAnchor = /* @__PURE__ */ new Map();
+	for (const rect of tablePageRects) {
+		const existing = tableRectsByAnchor.get(rect.anchorBlockIndex) ?? [];
+		existing.push(rect);
+		tableRectsByAnchor.set(rect.anchorBlockIndex, existing);
+	}
+	const anchorIndices = /* @__PURE__ */ new Set([...zonesByAnchor.keys(), ...tableRectsByAnchor.keys()]);
 	let cumulativeY = 0;
 	let pageRelativeY = 0;
+	let columnRegionMaxBottom = 0;
 	let activeZones = [];
+	let activeTablePageRects = [];
+	const contentLeftInput = pageGeometry?.contentLeft ?? pageGeometry?.marginLeft ?? 0;
+	const defaultContentLeft = Array.isArray(contentLeftInput) ? contentLeftInput[0] ?? 0 : contentLeftInput;
+	const physicalMarginTopInput = pageGeometry?.physicalPage?.marginTop ?? marginTop;
+	const defaultPhysicalMarginTop = Array.isArray(physicalMarginTopInput) ? physicalMarginTopInput[0] ?? 0 : physicalMarginTopInput;
+	const columnIndexInput = pageGeometry?.columnIndex ?? 0;
+	const columnCountInput = pageGeometry?.columnCount ?? 1;
 	return blocks.map((block, blockIndex) => {
 		recordMeasureBlock(blockIndex, block);
-		if (block.kind === "pageBreak" || isNextPageSectionBreak(block)) {
+		const blockWidth = Array.isArray(contentWidth) ? contentWidth[blockIndex] ?? defaultWidth : contentWidth;
+		const blockContentLeft = perBlockNumberValue(contentLeftInput, blockIndex, defaultContentLeft);
+		const blockContentTop = perBlockNumberValue(physicalMarginTopInput, blockIndex, defaultPhysicalMarginTop);
+		const blockColumnIndex = perBlockNumberValue(columnIndexInput, blockIndex, 0);
+		const blockColumnCount = perBlockNumberValue(columnCountInput, blockIndex, 1);
+		if (block.kind === "pageBreak" || isNextPageSectionBreak(block) || hasPageBreakBefore(block)) {
 			activeZones = [];
+			activeTablePageRects = [];
+			cumulativeY = 0;
+			pageRelativeY = 0;
+			columnRegionMaxBottom = 0;
+		} else if (block.kind === "columnBreak") {
+			if (blockColumnIndex + 1 >= blockColumnCount) {
+				activeZones = [];
+				activeTablePageRects = [];
+				columnRegionMaxBottom = 0;
+			} else columnRegionMaxBottom = Math.max(columnRegionMaxBottom, pageRelativeY);
 			cumulativeY = 0;
 			pageRelativeY = 0;
 		}
 		if (anchorIndices.has(blockIndex)) {
 			activeZones = zonesByAnchor.get(blockIndex) ?? [];
-			cumulativeY = activeZones.length > 0 && activeZones.every((z) => z.fullWidthBlock) ? pageRelativeY : 0;
+			activeTablePageRects = (tableRectsByAnchor.get(blockIndex) ?? []).map((template) => activateFloatingTablePageRect(template, blockContentTop + pageRelativeY));
+			cumulativeY = activeTablePageRects.length === 0 && activeZones.length > 0 && activeZones.every((z) => z.fullWidthBlock) || activeTablePageRects.length > 0 ? pageRelativeY : 0;
 		}
-		const zones = activeZones.length > 0 ? activeZones : void 0;
+		const projectedTableZones = activeTablePageRects.map((rect) => projectFloatingTablePageRect({
+			rect,
+			contentLeft: blockContentLeft,
+			contentTop: blockContentTop,
+			contentWidth: blockWidth
+		}));
+		const zones = activeZones.length > 0 || projectedTableZones.length > 0 ? [...activeZones, ...projectedTableZones] : void 0;
 		try {
-			const blockWidth = Array.isArray(contentWidth) ? contentWidth[blockIndex] ?? defaultWidth : contentWidth;
 			const measure = measureBlock(block, blockWidth, zones, cumulativeY, fieldValues);
 			const clearingZones = measure.kind === "table" ? zones : zones?.filter((zone) => zone.fullWidthBlock);
 			if (clearingZones?.length && (measure.kind === "image" || measure.kind === "table" && !block.floating)) {
@@ -549,6 +710,12 @@ function measureBlocks(blocks, contentWidth, marginTop = 0, pageGeometry, fieldV
 				cumulativeY += measure.totalHeight;
 				pageRelativeY += measure.totalHeight;
 			}
+			if (isContinuousSectionBreak(block)) {
+				const nextSectionY = Math.max(pageRelativeY, columnRegionMaxBottom);
+				cumulativeY = nextSectionY;
+				pageRelativeY = nextSectionY;
+				columnRegionMaxBottom = 0;
+			}
 			return measure;
 		} catch (error) {
 			recordMeasureBlockError(blockIndex, block, error);

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

@@ -1,6 +1,7 @@
+import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
 import { SCRIPT_CLASS, hasCjk, hasComplexScript, scriptClassOf, segmentByScript } from "../../utils/scriptSegments.js";
 import { getCachedFontMetrics, getCachedTextWidth, getTextWidthCacheGeneration, setCachedFontMetrics, setCachedTextWidth } from "./cache.js";
-import { hasComplexScriptFormatting, resolveComplexScriptFormatting } from "./complexScriptFormatting.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";
@@ -73,7 +74,9 @@ function canvasGetFontMetrics(style) {
 	const bold = style.bold ?? false;
 	const italic = style.italic ?? false;
 	const fontVariant = style.fontVariant;
-	const cached = getCachedFontMetrics(fontFamily, fontSize, bold, italic, fontVariant);
+	const alternateFontFamily = style.alternateFontFamily;
+	const fontCacheFamily = alternateFontFamily ? `${fontFamily}\u0000${alternateFontFamily}` : fontFamily;
+	const cached = getCachedFontMetrics(fontCacheFamily, fontSize, bold, italic, fontVariant);
 	if (cached !== void 0) return {
 		fontSize,
 		ascent: cached.ascent,
@@ -97,7 +100,7 @@ function canvasGetFontMetrics(style) {
 		}
 	} catch {}
 	lineHeight = Math.max(lineHeight, ascent + descent);
-	const singleLineRatio = getResolvedData(fontFamily).singleLineRatio;
+	const singleLineRatio = getResolvedData(fontFamily, alternateFontFamily).singleLineRatio;
 	const result = {
 		fontSize,
 		ascent,
@@ -106,7 +109,7 @@ function canvasGetFontMetrics(style) {
 		fontFamily,
 		singleLineRatio
 	};
-	setCachedFontMetrics(fontFamily, fontSize, bold, italic, result, fontVariant);
+	setCachedFontMetrics(fontCacheFamily, fontSize, bold, italic, result, fontVariant);
 	return result;
 }
 /**
@@ -118,16 +121,13 @@ function canvasGetFontMetrics(style) {
 */
 function canvasMeasureTextWidth(text, sourceStyle) {
 	if (!text) return 0;
-	const style = sourceStyle.forceComplexScript ? {
-		...sourceStyle,
-		...resolveComplexScriptFormatting(sourceStyle)
-	} : sourceStyle;
+	const style = sourceStyle.forceComplexScript ? applyComplexScriptFormatting(sourceStyle, sourceStyle) : sourceStyle;
 	const measuredText = applyTextTransform(text, style);
 	if (!sourceStyle.forceComplexScript && !style.letterSpacing && needsPerScriptFonts(style, measuredText)) return measureMixedScriptWidth(measuredText, style);
 	const ctx = getCanvasContext();
 	const font = buildFontString(style);
 	const letterSpacing = style.letterSpacing ?? 0;
-	const horizontalScale = getHorizontalScaleFactor(style);
+	const horizontalScale = getHorizontalScaleFactor(style.horizontalScale);
 	const fontKerning = getFontKerningMode(style);
 	const fontCacheKey = style.kerning ? `${font}|kerning:normal|scale:${horizontalScale}` : `${font}|scale:${horizontalScale}`;
 	const cached = getCachedTextWidth(measuredText, fontCacheKey, letterSpacing);
@@ -164,6 +164,7 @@ function canvasMeasureTextWidth(text, sourceStyle) {
 function glyphAdvanceStyle(style) {
 	const result = {};
 	if (style.fontFamily !== void 0) result.fontFamily = style.fontFamily;
+	if (style.alternateFontFamily !== void 0) result.alternateFontFamily = style.alternateFontFamily;
 	if (style.fontSize !== void 0) result.fontSize = style.fontSize;
 	if (style.bold !== void 0) result.bold = style.bold;
 	if (style.italic !== void 0) result.italic = style.italic;
@@ -190,20 +191,20 @@ function needsPerScriptFonts(style, measuredText) {
 function scriptStyle(style, script) {
 	if (script === SCRIPT_CLASS.eastAsia) {
 		if (style.eastAsiaFontFamily === void 0) return style;
-		return {
+		const result = {
 			...style,
 			fontFamily: style.eastAsiaFontFamily
 		};
+		delete result.alternateFontFamily;
+		if (style.eastAsiaAlternateFontFamily !== void 0) result.alternateFontFamily = style.eastAsiaAlternateFontFamily;
+		return result;
 	}
-	if (script === SCRIPT_CLASS.complex) return {
-		...style,
-		...resolveComplexScriptFormatting(style)
-	};
+	if (script === SCRIPT_CLASS.complex) return applyComplexScriptFormatting(style, style);
 	return style;
 }
 function measureMixedScriptWidth(measuredText, style) {
 	const letterSpacing = style.letterSpacing ?? 0;
-	const horizontalScale = getHorizontalScaleFactor(style);
+	const horizontalScale = getHorizontalScaleFactor(style.horizontalScale);
 	let glyphWidth = 0;
 	for (const segment of segmentByScript(measuredText)) glyphWidth += canvasMeasureTextWidth(segment.text, glyphAdvanceStyle(scriptStyle(style, segment.script)));
 	let width = glyphWidth;
@@ -262,10 +263,7 @@ function canvasMeasureText(text, style) {
 * @returns Run measurement with width and per-character widths
 */
 function canvasMeasureRun(text, sourceStyle) {
-	const style = sourceStyle.forceComplexScript ? {
-		...sourceStyle,
-		...resolveComplexScriptFormatting(sourceStyle)
-	} : sourceStyle;
+	const style = sourceStyle.forceComplexScript ? applyComplexScriptFormatting(sourceStyle, sourceStyle) : sourceStyle;
 	const metrics = canvasGetFontMetrics(style);
 	if (!text) return {
 		width: 0,
@@ -278,11 +276,12 @@ function canvasMeasureRun(text, sourceStyle) {
 	ctx.fontKerning = style.kerning ? "normal" : "none";
 	const eastAsiaFont = style.eastAsiaFontFamily !== void 0 && !style.letterSpacing ? buildFontString({
 		...style,
-		fontFamily: style.eastAsiaFontFamily
+		fontFamily: style.eastAsiaFontFamily,
+		...style.eastAsiaAlternateFontFamily !== void 0 ? { alternateFontFamily: style.eastAsiaAlternateFontFamily } : {}
 	}) : void 0;
 	const complexScriptFont = hasComplexScriptFormatting(style) && !style.letterSpacing ? buildFontString(scriptStyle(style, SCRIPT_CLASS.complex)) : void 0;
 	const letterSpacing = style.letterSpacing ?? 0;
-	const scale = getHorizontalScaleFactor(style);
+	const scale = getHorizontalScaleFactor(style.horizontalScale);
 	const charWidths = [];
 	let totalWidth = 0;
 	let offset = 0;
@@ -329,8 +328,5 @@ function applyTextTransform(text, style) {
 	if (style.textTransform === "uppercase") return text.toLocaleUpperCase();
 	return text;
 }
-function getHorizontalScaleFactor(style) {
-	return (style.horizontalScale ?? 100) / 100;
-}
 //#endregion
 export { canvasMeasureProvider, getCanvasContext, installCanvasMeasureProvider, resetCanvasContext };

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

@@ -21,7 +21,7 @@ type ResolvedFontCache = {
 /**
  * Get the resolved font data for a font family, with caching.
  */
-declare function getResolvedData(fontFamily: string): ResolvedFontCache;
+declare function getResolvedData(fontFamily: string, alternateFontFamily?: string): ResolvedFontCache;
 /**
  * Clear the resolved-font-family cache. `resolveFontFamily`'s output for a
  * given key can change even when the raw font names don't — e.g. when the

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

@@ -1,5 +1,6 @@
 import { resolveFontFamily } from "../../utils/fontResolver.js";
 import "../../utils/fontWeights.js";
+import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
 import { FONT_KERNING_MODE, getRunFontKerningMode } from "./textMeasurementPolicy.js";
 //#region src/layout-engine/measure/measureHelpers.ts
 /**
@@ -28,10 +29,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 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 } : {},
 		...run.complexScriptFontFamily !== void 0 ? { complexScriptFontFamily: run.complexScriptFontFamily } : {},
+		...run.complexScriptAlternateFontFamily !== void 0 ? { complexScriptAlternateFontFamily: run.complexScriptAlternateFontFamily } : {},
 		...run.complexScriptFontSize !== void 0 ? { complexScriptFontSize: run.complexScriptFontSize } : {},
 		...run.complexScriptBold !== void 0 ? { complexScriptBold: run.complexScriptBold } : {},
 		...run.complexScriptItalic !== void 0 ? { complexScriptItalic: run.complexScriptItalic } : {},
@@ -42,7 +47,7 @@ function buildRunFontStyle(run, fallbackFontFamily, fallbackFontSize) {
 		...run.letterSpacing !== void 0 ? { letterSpacing: run.letterSpacing } : {},
 		...run.allCaps ? { textTransform: "uppercase" } : {},
 		...run.smallCaps ? { fontVariant: "small-caps" } : {},
-		...run.horizontalScale !== void 0 ? { horizontalScale: run.horizontalScale } : {},
+		...horizontalScale !== void 0 ? { horizontalScale } : {},
 		kerning: getRunFontKerningMode(run, fallbackFontSize) === FONT_KERNING_MODE.enabled
 	};
 }
@@ -51,23 +56,24 @@ const fontResolvedCache = /* @__PURE__ */ new Map();
 /**
 * Get the resolved font data for a font family, with caching.
 */
-function getResolvedData(fontFamily) {
-	let cached = fontResolvedCache.get(fontFamily);
+function getResolvedData(fontFamily, alternateFontFamily) {
+	const cacheKey = `${fontFamily}\u0000${alternateFontFamily ?? ""}`;
+	let cached = fontResolvedCache.get(cacheKey);
 	if (cached === void 0) {
-		const resolved = resolveFontFamily(fontFamily);
+		const resolved = resolveFontFamily(fontFamily, alternateFontFamily);
 		cached = {
 			cssFallback: resolved.cssFallback,
 			singleLineRatio: resolved.singleLineRatio
 		};
-		fontResolvedCache.set(fontFamily, cached);
+		fontResolvedCache.set(cacheKey, cached);
 	}
 	return cached;
 }
 /**
 * Get the CSS fallback string for a font family, with caching.
 */
-function getResolvedFallback(fontFamily) {
-	return getResolvedData(fontFamily).cssFallback;
+function getResolvedFallback(fontFamily, alternateFontFamily) {
+	return getResolvedData(fontFamily, alternateFontFamily).cssFallback;
 }
 /**
 * Clear the resolved-font-family cache. `resolveFontFamily`'s output for a
@@ -102,7 +108,7 @@ function buildFontString(style) {
 	const fontSizePx = ptToPx(style.fontSize ?? 11);
 	parts.push(`${fontSizePx}px`);
 	const fontFamily = style.fontFamily ?? "Calibri";
-	parts.push(getResolvedFallback(fontFamily));
+	parts.push(getResolvedFallback(fontFamily, style.alternateFontFamily));
 	return parts.join(" ");
 }
 /**