@stll/folio-core 0.25.2 → 0.25.4

package/dist/layout-bridge/convert/toFlowBlocks.js

@@ -1,6 +1,7 @@
 import { convertBulletToUnicode } from "../../docx/bulletMarkers.js";
 import { resolveDocumentGridLinePitch } from "../../docx/documentGrid.js";
 import { formatOoxmlCounter } from "../../docx/ooxmlCounterFormatter.js";
+import { setHyperlinkInstanceIndex } from "../../layout-engine/measure/hyperlinkInstance.js";
 import { setParagraphFrame } from "../../layout-engine/paragraphFrame.js";
 import { setTextBoxGroupId } from "../../layout-engine/textBoxGroup.js";
 import { DEFAULT_TEXTBOX_MARGINS } from "../../layout-engine/types.js";
@@ -267,6 +268,7 @@ function extractRunFormatting(marks, theme) {
 			const attrs = expectHyperlinkMarkAttrs(mark);
 			const link = { href: attrs.href };
 			if (attrs.tooltip !== void 0) link.tooltip = attrs.tooltip;
+			if (attrs._docxHyperlinkIndex !== void 0) setHyperlinkInstanceIndex(link, attrs._docxHyperlinkIndex);
 			formatting.hyperlink = link;
 			break;
 		}
@@ -468,10 +470,7 @@ const TOC_STYLE_ID = /^TOC\d*$/iu;
 */
 function stripTocHyperlinkStyle(formatting) {
 	if (!formatting.hyperlink) return;
-	formatting.hyperlink = {
-		...formatting.hyperlink,
-		noDefaultStyle: true
-	};
+	formatting.hyperlink.noDefaultStyle = true;
 	delete formatting.color;
 	delete formatting.underline;
 }

package/dist/layout-bridge/engine/clickToPosition.js

@@ -1,6 +1,7 @@
 import { measuredLineAdvance, measuredLineContentOffset } from "../../layout-engine/lineFlow.js";
 import { buildRunFontStyle, findCharacterAtX } from "../../layout-engine/measure/measureHelpers.js";
 import { measureRun } from "../../layout-engine/measure/measureProvider.js";
+import { resolvePhysicalParagraphInlineLayout } from "../../utils/paragraphInlineLayout.js";
 import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
 //#region src/layout-bridge/engine/clickToPosition.ts
 /**
@@ -120,24 +121,12 @@ function findLineAtY(measure, localY, fromLine, toLine) {
 	if (toLine > fromLine) return Math.min(toLine - 1, measure.lines.length - 1);
 	return null;
 }
-/**
-* Find the character position at an X coordinate within a line.
-*
-* Uses canvas text measurement for pixel-perfect accuracy.
-*
-* @param block - The paragraph block.
-* @param line - The measured line.
-* @param x - X coordinate relative to the line's start position.
-* @param availableWidth - Available width for alignment calculations.
-* @returns Character offset and PM position.
-*/
-function findCharacterInLine(block, line, x, availableWidth) {
+function findCharacterInLine({ block, line, x, availableWidth, alignment }) {
 	const { pmStart, pmEnd } = computeLinePmRange(block, line);
 	if (pmStart === void 0 || pmEnd === void 0) return {
 		charOffset: 0,
 		pmPosition: block.pmStart ?? 0
 	};
-	const alignment = block.attrs?.alignment ?? "left";
 	let alignmentOffset = 0;
 	if (alignment === "center") alignmentOffset = Math.max(0, (availableWidth - line.width) / 2);
 	else if (alignment === "right") alignmentOffset = Math.max(0, availableWidth - line.width);
@@ -236,11 +225,15 @@ function clickToPositionInParagraph(fragmentHit) {
 	if (lineIndex === null) return null;
 	const line = paragraphMeasure.lines[lineIndex];
 	if (!line) return null;
-	const indent = paragraphBlock.attrs?.indent;
-	const indentLeft = indent?.left ?? 0;
-	const indentRight = indent?.right ?? 0;
+	const { alignment, indentLeft, indentRight } = resolvePhysicalParagraphInlineLayout(paragraphBlock);
 	const availableWidth = Math.max(0, fragment.width - indentLeft - indentRight);
-	const { charOffset, pmPosition } = findCharacterInLine(paragraphBlock, line, localX - indentLeft, availableWidth);
+	const { charOffset, pmPosition } = findCharacterInLine({
+		block: paragraphBlock,
+		line,
+		x: localX - indentLeft,
+		availableWidth,
+		alignment
+	});
 	return {
 		pmPosition,
 		charOffset,
@@ -254,7 +247,7 @@ function clickToPositionInParagraph(fragmentHit) {
 * @returns PM position, or null if mapping fails.
 */
 function clickToPositionInTableCell(tableCellHit) {
-	const { cellBlock, cellMeasure, cellLocalX, cellLocalY } = tableCellHit;
+	const { cellBlock, cellMeasure, cellLocalX, cellLocalY, cellContentWidth } = tableCellHit;
 	if (!cellBlock || !cellMeasure) return null;
 	return clickToPositionInParagraph({
 		fragment: {
@@ -262,7 +255,7 @@ function clickToPositionInTableCell(tableCellHit) {
 			blockId: cellBlock.id,
 			x: 0,
 			y: 0,
-			width: getMaxLineWidth(cellMeasure.lines, 100),
+			width: cellContentWidth,
 			fromLine: 0,
 			toLine: cellMeasure.lines.length,
 			height: cellMeasure.totalHeight
@@ -371,21 +364,13 @@ function positionToX(block, measure, pmPosition, _fragmentWidth) {
 	}
 	return null;
 }
-const getMaxLineWidth = (lines, fallback) => {
-	let maxWidth = fallback;
-	for (const line of lines) maxWidth = Math.max(maxWidth, line.width);
-	return maxWidth;
-};
 /**
 * Get the bounding rect for a PM position (for caret rendering).
 */
 function getPositionRect(block, measure, pmPosition, fragmentX, fragmentY, fragmentWidth, fromLine) {
 	const result = positionToX(block, measure, pmPosition, fragmentWidth);
 	if (!result) return null;
-	const alignment = block.attrs?.alignment ?? "left";
-	const indent = block.attrs?.indent;
-	const indentLeft = indent?.left ?? 0;
-	const indentRight = indent?.right ?? 0;
+	const { alignment, indentLeft, indentRight } = resolvePhysicalParagraphInlineLayout(block);
 	const availableWidth = Math.max(0, fragmentWidth - indentLeft - indentRight);
 	const line = measure.lines[result.lineIndex];
 	if (!line) return null;

package/dist/layout-bridge/engine/hitTest.d.ts

@@ -57,6 +57,8 @@ type TableCellHit = {
   cellMeasure?: ParagraphMeasure;
   /** X position relative to cell content area. */
   cellLocalX: number;
+  /** Width of the cell content area after physical padding. */
+  cellContentWidth: number;
   /** Y position relative to cell content area. */
   cellLocalY: number;
 };

package/dist/layout-bridge/engine/hitTest.js

@@ -1,6 +1,8 @@
 import { getHeaderRowsHeight } from "../../layout-engine/index.js";
 import { measuredLineRangeHeight } from "../../layout-engine/lineFlow.js";
-import { getTableRowLeadingWidth } from "../../layout-engine/types.js";
+import { getTableCellContentWidth } from "../../layout-engine/measure/tableCellFloating.js";
+import { buildTableCellGrid, buildTableCellPlacements } from "../../layout-engine/measure/tableCellGrid.js";
+import { resolveTableCellPadding } from "../../layout-engine/types.js";
 //#region src/layout-bridge/engine/hitTest.ts
 /**
 * Hit Testing Utilities
@@ -214,21 +216,33 @@ function hitTestTableCell(pageHit, blocks, measures, pagePoint) {
 		const rowMeasure = tableMeasure.rows[rowIndex];
 		const row = tableBlock.rows[rowIndex];
 		if (!rowMeasure || !row) continue;
-		let colX = getTableRowLeadingWidth(row, tableMeasure.columnWidths);
 		let colIndex = -1;
+		let cellLeft = 0;
 		if (rowMeasure.cells.length === 0 || row.cells.length === 0) continue;
-		for (let c = 0; c < rowMeasure.cells.length; c++) {
-			const cellMeasure = rowMeasure.cells[c];
-			if (localX >= colX && localX < colX + cellMeasure.width) {
+		const cellPlacements = buildTableCellPlacements({
+			grid: buildTableCellGrid(tableBlock.rows, tableMeasure.columnWidths.length),
+			columnWidths: tableMeasure.columnWidths,
+			bidi: tableBlock.bidi === true
+		});
+		let nearestDistance = Infinity;
+		for (let c = 0; c < row.cells.length; c++) {
+			const cell = row.cells[c];
+			if (!cell) continue;
+			const placement = cellPlacements.get(cell);
+			if (!placement) continue;
+			if (localX >= placement.left && localX < placement.left + placement.width) {
 				colIndex = c;
+				cellLeft = placement.left;
 				break;
 			}
-			colX += cellMeasure.width;
-		}
-		if (colIndex === -1) {
-			colIndex = rowMeasure.cells.length - 1;
-			if (colIndex < 0) continue;
+			const distance = Math.min(Math.abs(localX - placement.left), Math.abs(localX - placement.left - placement.width));
+			if (distance < nearestDistance) {
+				nearestDistance = distance;
+				colIndex = c;
+				cellLeft = placement.left;
+			}
 		}
+		if (colIndex === -1) continue;
 		const cellMeasure = rowMeasure.cells[colIndex];
 		const cell = row.cells[colIndex];
 		if (!cellMeasure || !cell) continue;
@@ -239,8 +253,6 @@ function hitTestTableCell(pageHit, blocks, measures, pagePoint) {
 			rowTop = headerHeight;
 			for (let r = tableFragment.fromRow; r < rowIndex; r++) rowTop += tableMeasure.rows[r]?.height ?? 0;
 		}
-		let colLeft = 0;
-		for (let c = 0; c < colIndex; c++) colLeft += rowMeasure.cells[c]?.width ?? 0;
 		let cellBlock;
 		let cellBlockMeasure;
 		if (cell.blocks.length > 0) {
@@ -251,7 +263,9 @@ function hitTestTableCell(pageHit, blocks, measures, pagePoint) {
 				cellBlockMeasure = firstMeasure;
 			}
 		}
-		const cellLocalX = localX - colLeft;
+		const { left: padLeft } = resolveTableCellPadding(cell);
+		const cellLocalX = localX - cellLeft - padLeft;
+		const cellContentWidth = getTableCellContentWidth(cell, cellMeasure);
 		const clipOffset = isClickOnHeader ? 0 : tableFragment.topClip ?? 0;
 		const cellLocalY = localY - rowTop + clipOffset;
 		return {
@@ -264,6 +278,7 @@ function hitTestTableCell(pageHit, blocks, measures, pagePoint) {
 			...cellBlock !== void 0 ? { cellBlock } : {},
 			...cellBlockMeasure !== void 0 ? { cellMeasure: cellBlockMeasure } : {},
 			cellLocalX: Math.max(0, cellLocalX),
+			cellContentWidth,
 			cellLocalY: Math.max(0, cellLocalY)
 		};
 	}

package/dist/layout-bridge/engine/selectionRects.js

@@ -4,7 +4,9 @@ import { buildRunFontStyle } from "../../layout-engine/measure/measureHelpers.js
 import { measureParagraph } from "../../layout-engine/measure/measureParagraph.js";
 import { measureRun } from "../../layout-engine/measure/measureProvider.js";
 import { buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages } from "../../layout-engine/measure/tableCellFloating.js";
-import { getTableRowLeadingWidth, resolveTableCellPadding } from "../../layout-engine/types.js";
+import { buildTableCellGrid, buildTableCellPlacements } from "../../layout-engine/measure/tableCellGrid.js";
+import { resolveTableCellPadding } from "../../layout-engine/types.js";
+import { resolvePhysicalParagraphInlineLayout } from "../../utils/paragraphInlineLayout.js";
 import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
 import { getPageTop } from "./hitTest.js";
 //#region src/layout-bridge/engine/selectionRects.ts
@@ -246,6 +248,7 @@ function selectionToRects(layout, blocks, measures, from, to) {
 	const selFrom = Math.min(from, to);
 	const selTo = Math.max(from, to);
 	const rects = [];
+	const tableCellPlacements = /* @__PURE__ */ new WeakMap();
 	for (let pageIndex = 0; pageIndex < layout.pages.length; pageIndex++) {
 		const page = layout.pages[pageIndex];
 		const pageTopY = getPageTop(layout, pageIndex);
@@ -260,6 +263,8 @@ function selectionToRects(layout, blocks, measures, from, to) {
 				const paragraphBlock = block;
 				const paragraphMeasure = measure;
 				const paragraphFragment = fragment;
+				const { alignment, indentLeft, indentRight } = resolvePhysicalParagraphInlineLayout(paragraphBlock);
+				const availableWidth = Math.max(0, fragment.width - indentLeft - indentRight);
 				const intersectingLines = findLinesInRange(paragraphBlock, paragraphMeasure, selFrom, selTo);
 				for (const { line, index } of intersectingLines) {
 					if (index < paragraphFragment.fromLine || index >= paragraphFragment.toLine) continue;
@@ -272,13 +277,8 @@ function selectionToRects(layout, blocks, measures, from, to) {
 					if (!isEmptyLine && sliceFrom >= sliceTo) continue;
 					const charOffsetFrom = pmPosToCharOffset(paragraphBlock, line, sliceFrom);
 					const charOffsetTo = pmPosToCharOffset(paragraphBlock, line, sliceTo);
-					const indent = paragraphBlock.attrs?.indent;
-					const indentLeft = indent?.left ?? 0;
-					const indentRight = indent?.right ?? 0;
-					const availableWidth = Math.max(0, fragment.width - indentLeft - indentRight);
 					const startX = charOffsetToX(paragraphBlock, line, charOffsetFrom, availableWidth);
 					const endX = charOffsetToX(paragraphBlock, line, charOffsetTo, availableWidth);
-					const alignment = paragraphBlock.attrs?.alignment ?? "left";
 					let alignmentOffset = 0;
 					if (alignment === "center") alignmentOffset = Math.max(0, (availableWidth - line.width) / 2);
 					else if (alignment === "right") alignmentOffset = Math.max(0, availableWidth - line.width);
@@ -305,6 +305,15 @@ function selectionToRects(layout, blocks, measures, from, to) {
 				const tableBlock = block;
 				const tableMeasure = measure;
 				const tableFragment = fragment;
+				let cellPlacements = tableCellPlacements.get(tableBlock);
+				if (!cellPlacements) {
+					cellPlacements = buildTableCellPlacements({
+						grid: buildTableCellGrid(tableBlock.rows, tableMeasure.columnWidths.length),
+						columnWidths: tableMeasure.columnWidths,
+						bidi: tableBlock.bidi === true
+					});
+					tableCellPlacements.set(tableBlock, cellPlacements);
+				}
 				const hdrCount = tableFragment.headerRowCount ?? 0;
 				let rowY = hdrCount > 0 && tableFragment.continuesFromPrev ? getHeaderRowsHeight(tableMeasure, hdrCount) : 0;
 				for (let rowIndex = tableFragment.fromRow; rowIndex < tableFragment.toRow && rowIndex < tableBlock.rows.length; rowIndex++) {
@@ -313,11 +322,12 @@ function selectionToRects(layout, blocks, measures, from, to) {
 					if (!row || !rowMeasure) continue;
 					const clipTop = tableFragment.topClip ?? 0;
 					const clipBottom = tableFragment.bottomClip ?? rowMeasure.height;
-					let cellX = getTableRowLeadingWidth(row, tableMeasure.columnWidths);
 					for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex++) {
 						const cell = row.cells[cellIndex];
 						const cellMeasure = rowMeasure.cells[cellIndex];
 						if (!cell || !cellMeasure) continue;
+						const placement = cellPlacements.get(cell);
+						if (!placement) continue;
 						const contentWidth = getTableCellContentWidth(cell, cellMeasure);
 						const floatingZones = buildTableCellFloatingZones(getTableCellFloatingImages(cell, cellMeasure, contentWidth), contentWidth);
 						const contentOffsetX = getCellContentOffsetX(cell);
@@ -340,6 +350,8 @@ function selectionToRects(layout, blocks, measures, from, to) {
 								floatingZones,
 								paragraphYOffset: blockY
 							});
+							const { alignment, indentLeft, indentRight } = resolvePhysicalParagraphInlineLayout(paragraphBlock);
+							const availableWidth = Math.max(0, contentWidth - indentLeft - indentRight);
 							const intersectingLines = findLinesInRange(paragraphBlock, paragraphMeasure, selFrom, selTo);
 							for (const { line, index } of intersectingLines) {
 								const range = computeLinePmRange(paragraphBlock, line);
@@ -351,13 +363,16 @@ function selectionToRects(layout, blocks, measures, from, to) {
 								if (!isEmptyLine && sliceFrom >= sliceTo) continue;
 								const charOffsetFrom = pmPosToCharOffset(paragraphBlock, line, sliceFrom);
 								const charOffsetTo = pmPosToCharOffset(paragraphBlock, line, sliceTo);
-								const startX = charOffsetToX(paragraphBlock, line, charOffsetFrom, contentWidth);
-								const endX = charOffsetToX(paragraphBlock, line, charOffsetTo, contentWidth);
+								const startX = charOffsetToX(paragraphBlock, line, charOffsetFrom, availableWidth);
+								const endX = charOffsetToX(paragraphBlock, line, charOffsetTo, availableWidth);
+								let alignmentOffset = 0;
+								if (alignment === "center") alignmentOffset = Math.max(0, (availableWidth - line.width) / 2);
+								else if (alignment === "right") alignmentOffset = Math.max(0, availableWidth - line.width);
 								const lineY = measuredLineContentOffset(paragraphMeasure.lines, 0, index);
 								const clippedLineY = contentOffsetY + blockY + lineY;
 								if (clippedLineY + line.lineHeight <= clipTop || clippedLineY >= clipBottom) continue;
 								rects.push({
-									x: tableFragment.x + cellX + contentOffsetX + Math.min(startX, endX),
+									x: tableFragment.x + placement.left + contentOffsetX + indentLeft + alignmentOffset + Math.min(startX, endX),
 									y: tableFragment.y + rowY + clippedLineY - clipTop + pageTopY,
 									width: isEmptyLine ? EMPTY_PARAGRAPH_SLIVER_WIDTH : Math.max(1, Math.abs(endX - startX)),
 									height: line.lineHeight,
@@ -366,7 +381,6 @@ function selectionToRects(layout, blocks, measures, from, to) {
 							}
 							blockY += paragraphMeasure.totalHeight;
 						}
-						cellX += cellMeasure.width;
 					}
 					rowY += rowMeasure.height;
 				}
@@ -419,12 +433,9 @@ function getCaretPosition(layout, blocks, measures, pmPosition) {
 					if (range.pmStart === void 0 || range.pmEnd === void 0) continue;
 					if (pmPosition >= range.pmStart && pmPosition <= range.pmEnd) {
 						const charOffset = pmPosToCharOffset(paragraphBlock, line, pmPosition);
-						const indent = paragraphBlock.attrs?.indent;
-						const indentLeft = indent?.left ?? 0;
-						const indentRight = indent?.right ?? 0;
+						const { alignment, indentLeft, indentRight } = resolvePhysicalParagraphInlineLayout(paragraphBlock);
 						const availableWidth = Math.max(0, fragment.width - indentLeft - indentRight);
 						const x = charOffsetToX(paragraphBlock, line, charOffset, availableWidth);
-						const alignment = paragraphBlock.attrs?.alignment ?? "left";
 						let alignmentOffset = 0;
 						if (alignment === "center") alignmentOffset = Math.max(0, (availableWidth - line.width) / 2);
 						else if (alignment === "right") alignmentOffset = Math.max(0, availableWidth - line.width);

package/dist/layout-engine/index.js

@@ -3,6 +3,7 @@ import { resolveSectionHeaderFooterRefs } from "./headerFooterRefs.js";
 import { calculateChainHeight, computeKeepNextChains, getMidChainIndices, hasKeepLines, hasPageBreakBefore } from "./keep-together.js";
 import { measuredLineAdvance } from "./lineFlow.js";
 import { resolveFloatingTableX } from "./measure/floatingTablePosition.js";
+import { resolveTableInlinePlacement } from "./measure/tableInlinePlacement.js";
 import { createPaginator } from "./paginator.js";
 import { getParagraphFragmentPmRange } from "./paragraphFragmentRange.js";
 import { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacingTree } from "./paragraphSpacing.js";
@@ -521,15 +522,11 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 	const breakInfo = buildTableRowBreakInfo(block, measure);
 	const verticallyMergedRows = getVerticallyMergedRows(block);
 	const computeTableX = (columnIndex) => {
-		let x = paginator.getColumnX(columnIndex);
-		if (block.justification === "center") x += (paginator.columnWidth - measure.totalWidth) / 2;
-		else if (block.justification === "right") x = x + paginator.columnWidth - measure.totalWidth;
-		else if (block.indent !== void 0) x += block.indent;
-		else {
-			const leadingCellMargin = block.rows.at(0)?.cells.at(0)?.padding?.left ?? 0;
-			x -= leadingCellMargin;
-		}
-		return x;
+		const x = paginator.getColumnX(columnIndex);
+		const placement = resolveTableInlinePlacement(block);
+		if (placement.alignment === "center") return x + (paginator.columnWidth - measure.totalWidth) / 2;
+		if (placement.alignment === "right") return x + paginator.columnWidth - measure.totalWidth - placement.offset;
+		return x + placement.offset;
 	};
 	const getCurrentRowCapacity = (state = paginator.getCurrentState()) => state.rawContentBottom - state.topMargin;
 	const hasAdjacentPriorTableRows = (rowIndex, state = paginator.getCurrentState()) => {

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

@@ -54,10 +54,7 @@ declare function setFontCacheSize(size: number): void;
  * Get current font metrics cache size
  */
 declare function getFontCacheSize(): number;
-/**
- * Generate a simple hash for a paragraph block
- * Used as cache key to identify identical content
- */
+/** Serialize the complete paragraph measurement contract into a cache key. */
 declare function hashParagraphBlock(block: ParagraphBlock): string;
 /**
  * Get cached paragraph measurement or return undefined

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

@@ -1,4 +1,3 @@
-import { lineBreakPolicyCacheParts } from "./effectiveLineBreakPolicy.js";
 import { getLineBreakProviderGeneration } from "./lineBreakProvider.js";
 import { clearFontResolvedCache } from "./measureHelpers.js";
 //#region src/layout-engine/measure/cache.ts
@@ -164,40 +163,38 @@ let paragraphCacheMaxSize = 5e3;
 * Key format: block content hash
 */
 const paragraphMeasureCache = /* @__PURE__ */ new Map();
-/**
-* Generate a simple hash for a paragraph block
-* Used as cache key to identify identical content
-*/
-function hashParagraphBlock(block) {
-	const parts = [`lbp:${getLineBreakProviderGeneration()}`];
-	for (const run of block.runs) if (run.kind === "text") parts.push(`t:${run.text}|${run.fontFamily}|${run.eastAsiaFontFamily}|${run.complexScriptFontFamily}|${run.fontSize}|${run.complexScriptFontSize}|${run.bold}|${run.complexScriptBold}|${run.italic}|${run.complexScriptItalic}|${run.forceComplexScript}|${run.allCaps}|${run.smallCaps}|${run.horizontalScale}|${run.letterSpacing}|${run.language?.val}|${run.language?.eastAsia}|${run.language?.bidi}`);
-	else if (run.kind === "tab") parts.push(`tab:${run.width}`);
-	else if (run.kind === "image") parts.push(`img:${run.width}x${run.height}:${run.exactLineHeight === true ? "exact" : "text"}`);
-	else if (run.kind === "lineBreak") parts.push("br");
-	const attrs = block.attrs;
-	if (attrs) {
-		if (attrs.alignment) parts.push(`align:${attrs.alignment}`);
-		if (attrs.outlineLevel !== void 0) parts.push(`outline:${attrs.outlineLevel}`);
-		if (attrs.indent) parts.push(`indent:${attrs.indent.left}|${attrs.indent.right}|${attrs.indent.firstLine}|${attrs.indent.hanging}`);
-		if (attrs.spacing) parts.push(`spacing:${attrs.spacing.before}|${attrs.spacing.after}|${attrs.spacing.line}|${attrs.spacing.lineRule}`);
-		if (attrs.defaultFontSize != null) parts.push(`dfs:${attrs.defaultFontSize}`);
-		if (attrs.defaultFontFamily != null) parts.push(`dff:${attrs.defaultFontFamily}`);
-		if (attrs.suppressEmptyParagraphHeight) parts.push("sup");
-		if (attrs.reserveEmptyOutlineHeight) parts.push("outline-empty-reserve");
-		if (attrs.documentGridLinePitch !== void 0) parts.push(`documentGrid:${attrs.documentGridLinePitch}|${attrs.snapToGrid !== false}`);
-		if (attrs.justificationCompatibility) parts.push(`justify-compat:${attrs.justificationCompatibility.type}`);
-		if (attrs.listMarker !== void 0) {
-			const marker = attrs.listMarkerFormatting;
-			parts.push(`marker:${attrs.listMarker}|${attrs.listMarkerHidden}|${attrs.listMarkerAlignment}|${attrs.listMarkerSuffix}|${marker?.fontFamily}|${marker?.eastAsiaFontFamily}|${marker?.complexScriptFontFamily}|${marker?.fontSize}|${marker?.complexScriptFontSize}|${marker?.bold}|${marker?.complexScriptBold}|${marker?.italic}|${marker?.complexScriptItalic}|${marker?.rtl}|${marker?.forceComplexScript}`);
-		}
-		parts.push(...lineBreakPolicyCacheParts(attrs));
-		const borders = attrs.borders;
-		if (borders) {
-			const signature = (border) => border ? `${border.width ?? ""},${border.style ?? ""},${border.color ?? ""}` : "";
-			parts.push(`bdr:${signature(borders.top)}|${signature(borders.bottom)}|${signature(borders.left)}|${signature(borders.right)}`);
-		}
+/** Keep image payloads bounded while classifying every field as measured or intentionally ignored. */
+const imageMeasureCacheInput = (run) => ({
+	kind: run.kind,
+	width: run.width,
+	height: run.height,
+	transform: run.transform,
+	wrapType: run.wrapType,
+	displayMode: run.displayMode,
+	distTop: run.distTop,
+	distBottom: run.distBottom,
+	exactLineHeight: run.exactLineHeight,
+	positioned: run.position !== void 0
+});
+const runMeasureCacheInput = (run) => {
+	switch (run.kind) {
+		case "text":
+		case "tab":
+		case "lineBreak":
+		case "renderedPageBreak":
+		case "field":
+		case "math": return run;
+		case "image": return imageMeasureCacheInput(run);
+		default: return run;
 	}
-	return parts.join("||");
+};
+/** Serialize the complete paragraph measurement contract into a cache key. */
+function hashParagraphBlock(block) {
+	return JSON.stringify({
+		lineBreakProviderGeneration: getLineBreakProviderGeneration(),
+		attrs: block.attrs,
+		runs: block.runs.map(runMeasureCacheInput)
+	});
 }
 /**
 * Evict oldest entries if paragraph cache exceeds max size

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

@@ -0,0 +1,6 @@
+import { HyperlinkInfo } from "../types.js";
+//#region src/layout-engine/measure/hyperlinkInstance.d.ts
+declare const setHyperlinkInstanceIndex: (hyperlink: HyperlinkInfo, instanceIndex: number) => void;
+declare const getHyperlinkInstanceIndex: (hyperlink: HyperlinkInfo) => number | undefined;
+//#endregion
+export { getHyperlinkInstanceIndex, setHyperlinkInstanceIndex };

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

@@ -0,0 +1,8 @@
+//#region src/layout-engine/measure/hyperlinkInstance.ts
+const hyperlinkInstanceIndexes = /* @__PURE__ */ new WeakMap();
+const setHyperlinkInstanceIndex = (hyperlink, instanceIndex) => {
+	hyperlinkInstanceIndexes.set(hyperlink, instanceIndex);
+};
+const getHyperlinkInstanceIndex = (hyperlink) => hyperlinkInstanceIndexes.get(hyperlink);
+//#endregion
+export { getHyperlinkInstanceIndex, setHyperlinkInstanceIndex };

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

@@ -5,10 +5,24 @@ type TableCellGrid = {
   sourceCellsByRow: ReadonlyMap<number, ReadonlyMap<number, TableCell>>;
   sourceColumnsByCell: ReadonlyMap<TableCell, number>;
 };
+type TableCellPlacement = {
+  sourceColumn: number;
+  columnSpan: number;
+  left: number;
+  width: number;
+};
+type TableCellPlacements = ReadonlyMap<TableCell, TableCellPlacement>;
+type BuildTableCellPlacementsOptions = {
+  grid: TableCellGrid;
+  columnWidths: readonly number[];
+  bidi: boolean;
+};
 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;
 //#endregion
-export { TableCellGrid, buildTableCellGrid, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellVerticalBorderHeight };
+export { TableCellGrid, TableCellPlacement, TableCellPlacements, buildTableCellGrid, buildTableCellPlacements, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellVerticalBorderHeight };

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

@@ -6,10 +6,11 @@ const buildTableCellGrid = (rows, columnCount) => {
 	for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
 		const row = rows[rowIndex];
 		if (!row) continue;
-		let columnIndex = firstAvailableColumn(occupiedColumnsByRow.get(rowIndex), row.gridBefore ?? 0);
+		const gridBefore = Math.max(0, Math.min(columnCount, Math.trunc(row.gridBefore ?? 0)));
+		let columnIndex = firstAvailableColumn(occupiedColumnsByRow.get(rowIndex), gridBefore);
 		for (const cell of row.cells) {
-			const columnSpan = cell.colSpan ?? 1;
-			const rowSpan = cell.rowSpan ?? 1;
+			const columnSpan = Math.max(1, Math.trunc(cell.colSpan ?? 1));
+			const rowSpan = Math.max(1, Math.trunc(cell.rowSpan ?? 1));
 			sourceColumnsByCell.set(cell, columnIndex);
 			const rowEnd = Math.min(rows.length, rowIndex + rowSpan);
 			const columnEnd = Math.min(columnCount, columnIndex + columnSpan);
@@ -17,9 +18,9 @@ const buildTableCellGrid = (rows, columnCount) => {
 				const cellsByColumn = getOrCreateCellRow(sourceCellsByRow, gridRowIndex);
 				for (let gridColumnIndex = columnIndex; gridColumnIndex < columnEnd; gridColumnIndex++) cellsByColumn.set(gridColumnIndex, cell);
 			}
-			if (rowSpan > 1) for (let spannedRowIndex = rowIndex + 1; spannedRowIndex < rowIndex + rowSpan; spannedRowIndex++) {
+			if (rowSpan > 1) for (let spannedRowIndex = rowIndex + 1; spannedRowIndex < rowEnd; spannedRowIndex++) {
 				const occupied = getOrCreateOccupiedRow(occupiedColumnsByRow, spannedRowIndex);
-				for (let columnOffset = 0; columnOffset < columnSpan; columnOffset++) occupied.add(columnIndex + columnOffset);
+				for (let gridColumnIndex = columnIndex; gridColumnIndex < columnEnd; gridColumnIndex++) occupied.add(gridColumnIndex);
 			}
 			columnIndex = firstAvailableColumn(occupiedColumnsByRow.get(rowIndex), columnIndex + columnSpan);
 		}
@@ -33,6 +34,28 @@ const buildTableCellGrid = (rows, columnCount) => {
 const getFirstAvailableColumn = (grid, rowIndex, startingColumn) => firstAvailableColumn(grid.occupiedColumnsByRow.get(rowIndex), startingColumn);
 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 columnOffsets = [0];
+	for (const columnWidth of columnWidths) columnOffsets.push((columnOffsets.at(-1) ?? 0) + columnWidth);
+	const tableWidth = columnOffsets.at(-1) ?? 0;
+	const placements = /* @__PURE__ */ new Map();
+	for (const [cell, sourceColumn] of grid.sourceColumnsByCell) {
+		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 width = logicalRight - logicalLeft;
+		placements.set(cell, {
+			sourceColumn,
+			columnSpan,
+			left: bidi ? tableWidth - logicalRight : logicalLeft,
+			width
+		});
+	}
+	return placements;
+};
 const getTableCellVerticalBorderHeight = (grid, cell, rowIndex) => {
 	const sourceColumn = cell ? getSourceCellColumn(grid, cell) : void 0;
 	const aboveBottom = (sourceColumn === void 0 ? void 0 : getSourceCellAt(grid, rowIndex - 1, sourceColumn))?.borders?.bottom;
@@ -59,4 +82,4 @@ const getOrCreateOccupiedRow = (occupiedColumnsByRow, rowIndex) => {
 	return occupiedColumns;
 };
 //#endregion
-export { buildTableCellGrid, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellVerticalBorderHeight };
+export { buildTableCellGrid, buildTableCellPlacements, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellVerticalBorderHeight };

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

@@ -0,0 +1,12 @@
+import { TableBlock } from "../types.js";
+//#region src/layout-engine/measure/tableInlinePlacement.d.ts
+type TableInlinePlacement = {
+  alignment: "center";
+} | {
+  alignment: "left" | "right";
+  offset: number;
+};
+/** Resolve an inline table's horizontal anchor without losing RTL leading-edge semantics. */
+declare const resolveTableInlinePlacement: (table: Pick<TableBlock, "bidi" | "indent" | "justification" | "rows">) => TableInlinePlacement;
+//#endregion
+export { resolveTableInlinePlacement };

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

@@ -0,0 +1,22 @@
+import { resolveTableCellPadding } from "../types.js";
+//#region src/layout-engine/measure/tableInlinePlacement.ts
+/** Resolve an inline table's horizontal anchor without losing RTL leading-edge semantics. */
+const resolveTableInlinePlacement = (table) => {
+	if (table.justification === "center") return { alignment: "center" };
+	if (table.justification === "right") return {
+		alignment: "right",
+		offset: 0
+	};
+	const firstCell = table.rows.at(0)?.cells.at(0);
+	const firstCellPadding = firstCell ? resolveTableCellPadding(firstCell) : void 0;
+	if (table.justification === "left" || table.bidi !== true) return {
+		alignment: "left",
+		offset: table.indent ?? -(firstCellPadding?.left ?? 0)
+	};
+	return {
+		alignment: "right",
+		offset: table.indent ?? -(firstCellPadding?.right ?? 0)
+	};
+};
+//#endregion
+export { resolveTableInlinePlacement };

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

@@ -632,7 +632,7 @@ type TableBlock = {
   layout?: "fixed" | "autofit";
   /** Table horizontal alignment */
   justification?: "left" | "center" | "right";
-  /** Table indent from left margin (in pixels, from w:tblInd) */
+  /** Table indent from the leading margin (in pixels, from w:tblInd). */
   indent?: number;
   /** Right-to-left column order (w:bidiVisual): logical column 0 paints on the right. */
   bidi?: boolean;

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

@@ -1,5 +1,6 @@
 import { HyperlinkInfo, MeasuredLine, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphMeasure, Run, TabStop } from "../layout-engine/types.js";
 import { RenderContext } from "./renderUtils.js";
+import { PhysicalParagraphInlineLayout } from "../utils/paragraphInlineLayout.js";
 //#region src/layout-painter/renderParagraph.d.ts
 /**
  * CSS class names for paragraph rendering
@@ -70,6 +71,8 @@ type RenderLineOptions = {
   firstLineIndentPx?: number;
   /** Paragraph base direction for logical first-line indentation. */
   isRtl?: boolean;
+  /** Explicit alignment after resolving authored bidi physical sides. */
+  explicitAlignment?: PhysicalParagraphInlineLayout["explicitAlignment"];
   /** Full paragraph content-box width before physical indents. */
   contentWidthPx?: number;
   /** Line-specific floating image margins (calculated per-line based on Y overlap) */