@stll/folio-core 0.25.2 → 0.25.3

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/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) */

package/dist/layout-painter/renderParagraph.js

@@ -2,6 +2,7 @@ import { ommlToMathml } from "../docx/mathToMathml.js";
 import { parseXmlDocument } from "../docx/xmlParser.js";
 import { evaluateFieldInstruction } from "../fields/evaluateField.js";
 import { hasComplexScriptFormatting, resolveComplexScriptFormatting } from "../layout-engine/measure/complexScriptFormatting.js";
+import { getHyperlinkInstanceIndex } from "../layout-engine/measure/hyperlinkInstance.js";
 import { getListMarkerInlineWidth, getListMarkerVisualOffset, resolveListMarkerFont } from "../layout-engine/measure/listMarkerWidth.js";
 import { DOCX_SCRIPT_FONT_SCALE } from "../layout-engine/measure/measureHelpers.js";
 import { FONT_KERNING_MODE, countCompressibleSpaces, getFontKerningMode, getRunFontKerningMode, toPaintedText } from "../layout-engine/measure/textMeasurementPolicy.js";
@@ -10,7 +11,7 @@ import { calculateTabWidth } from "../prosemirror/utils/tabCalculator.js";
 import { AUTHOR_COLORS, getAuthorColorIdx } from "../utils/authorColors.js";
 import { resolveFontFamily } from "../utils/fontResolver.js";
 import "../utils/fontWeights.js";
-import { isRtlParagraph } from "../utils/paragraphBaseDirection.js";
+import { resolvePhysicalParagraphInlineLayout } from "../utils/paragraphInlineLayout.js";
 import { inlineImageBoundingBox, parseRotationDegrees, rotatedBoundingBox } from "../utils/rotationBoundingBox.js";
 import { applySanitizedImageSrc } from "../utils/sanitizeImageSrc.js";
 import { SCRIPT_CLASS, hasCjk, hasComplexScript, segmentByScript } from "../utils/scriptSegments.js";
@@ -49,6 +50,9 @@ function isTextRun(run) {
 	return run.kind === "text";
 }
 function hyperlinksMatch(left, right) {
+	const leftInstanceIndex = getHyperlinkInstanceIndex(left);
+	const rightInstanceIndex = getHyperlinkInstanceIndex(right);
+	if (leftInstanceIndex !== void 0 || rightInstanceIndex !== void 0) return leftInstanceIndex === rightInstanceIndex;
 	return left.href === right.href && left.tooltip === right.tooltip && left.noDefaultStyle === right.noDefaultStyle;
 }
 function collectLeftToRightDisplayedUrlHyperlinks(runs) {
@@ -1097,7 +1101,7 @@ function renderLine(block, line, alignment, doc, options) {
 		return runEl;
 	};
 	const onlyRun = runsForLine.length === 1 ? runsForLine[0] : void 0;
-	if (onlyRun && isMathRun(onlyRun) && onlyRun.display === "block" && block.attrs?.alignment !== "right") lineEl.style.textAlign = "center";
+	if (onlyRun && isMathRun(onlyRun) && onlyRun.display === "block" && (options?.explicitAlignment ?? resolvePhysicalParagraphInlineLayout(block).explicitAlignment) !== "right") lineEl.style.textAlign = "center";
 	if (runsForLine.length === 1 && isImageRun(runsForLine[0])) {
 		lineEl.style.display = "flex";
 		lineEl.style.alignItems = "center";
@@ -1342,26 +1346,15 @@ function renderParagraphFragment(fragment, block, measure, context, options = {}
 	if (fragment.continuesFromPrev) fragmentEl.dataset["continuesFromPrev"] = "true";
 	if (fragment.continuesOnNext) fragmentEl.dataset["continuesOnNext"] = "true";
 	const lines = measure.lines.slice(fragment.fromLine, fragment.toLine);
-	const alignment = block.attrs?.alignment;
+	const inlineLayout = resolvePhysicalParagraphInlineLayout(block);
+	const { alignment, indentLeft, indentRight, isRtl } = inlineLayout;
 	if (block.attrs?.styleId) fragmentEl.dataset["styleId"] = block.attrs.styleId;
-	const isRtl = isRtlParagraph(block);
 	if (isRtl) fragmentEl.dir = "rtl";
-	if (alignment) if (alignment === "center") fragmentEl.style.textAlign = "center";
-	else if (alignment === "right") fragmentEl.style.textAlign = "right";
-	else if (alignment === "left") fragmentEl.style.textAlign = "left";
-	else fragmentEl.style.textAlign = isRtl ? "right" : "left";
-	else if (isRtl) fragmentEl.style.textAlign = "right";
-	const effectiveAlignment = alignment ?? (isRtl ? "right" : void 0);
+	let fragmentAlignment = alignment;
+	if (alignment === "justify") fragmentAlignment = isRtl ? "right" : "left";
+	fragmentEl.style.textAlign = fragmentAlignment;
+	const effectiveAlignment = alignment;
 	const indent = block.attrs?.indent;
-	let indentLeft = 0;
-	let indentRight = 0;
-	if (indent) if (isRtl) {
-		if (indent.left !== void 0) indentRight = indent.left;
-		if (indent.right !== void 0) indentLeft = indent.right;
-	} else {
-		if (indent.left !== void 0) indentLeft = indent.left;
-		if (indent.right !== void 0) indentRight = indent.right;
-	}
 	const borders = block.attrs?.borders;
 	if (borders) {
 		const borderStyleToCss = (style) => {
@@ -1448,6 +1441,7 @@ function renderParagraphFragment(fragment, block, measure, context, options = {}
 			tabLeftIndentPx: indent?.left ?? 0,
 			firstLineIndentPx: isFirstLine ? firstLineIndentPx : 0,
 			isRtl,
+			...inlineLayout.explicitAlignment === void 0 ? {} : { explicitAlignment: inlineLayout.explicitAlignment },
 			contentWidthPx: fragment.width,
 			context,
 			floatingMargins: {

package/dist/layout-painter/renderTable.js

@@ -1,7 +1,9 @@
 import { measureParagraph } from "../layout-engine/measure/measureParagraph.js";
 import { buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages } from "../layout-engine/measure/tableCellFloating.js";
 import { createTableCellFlowState, finishTableCellFlow, placeTableCellBlock } from "../layout-engine/measure/tableCellFlow.js";
-import { getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, resolveTableCellPadding, tableColumnsArePinned } from "../layout-engine/types.js";
+import { buildTableCellGrid, buildTableCellPlacements, getSourceCellAt } from "../layout-engine/measure/tableCellGrid.js";
+import { resolveTableInlinePlacement } from "../layout-engine/measure/tableInlinePlacement.js";
+import { isFloatingImageRun, isFloatingTextBoxBlock, resolveTableCellPadding, tableColumnsArePinned } from "../layout-engine/types.js";
 import { applySanitizedImageSrc } from "../utils/sanitizeImageSrc.js";
 import { emuToPixels } from "../utils/units.js";
 import { resolveAnchoredImagePosition } from "./anchoredImagePosition.js";
@@ -228,11 +230,14 @@ function renderNestedTable(block, measure, context, doc) {
 	tableEl.style.position = "relative";
 	tableEl.style.width = `${measure.totalWidth}px`;
 	tableEl.style.display = "block";
-	if (block.justification === "center") {
+	const placement = resolveTableInlinePlacement(block);
+	if (placement.alignment === "center") {
 		tableEl.style.marginLeft = "auto";
 		tableEl.style.marginRight = "auto";
-	} else if (block.justification === "right") tableEl.style.marginLeft = "auto";
-	else if (block.indent) tableEl.style.marginLeft = `${block.indent}px`;
+	} else if (placement.alignment === "right") {
+		tableEl.style.marginLeft = "auto";
+		tableEl.style.marginRight = `${placement.offset}px`;
+	} else tableEl.style.marginLeft = `${placement.offset}px`;
 	tableEl.dataset["blockId"] = String(block.id);
 	if (block.pmStart !== void 0) tableEl.dataset["pmStart"] = String(block.pmStart);
 	if (block.pmEnd !== void 0) tableEl.dataset["pmEnd"] = String(block.pmEnd);
@@ -243,9 +248,13 @@ function renderNestedTable(block, measure, context, doc) {
 		yPos += i_item.height;
 	}
 	rowYPositions.push(yPos);
-	const spanningCells = /* @__PURE__ */ new Map();
 	const columnsPinned = tableColumnsArePinned(block);
-	const cellGrid = buildTableCellGrid(block, measure.columnWidths.length);
+	const cellGrid = buildTableCellGrid(block.rows, measure.columnWidths.length);
+	const cellPlacements = buildTableCellPlacements({
+		grid: cellGrid,
+		columnWidths: measure.columnWidths,
+		bidi: block.bidi === true
+	});
 	let y = 0;
 	for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex++) {
 		const row = block.rows[rowIndex];
@@ -264,11 +273,11 @@ function renderNestedTable(block, measure, context, doc) {
 			totalRows: block.rows.length,
 			context,
 			doc,
-			spanningCells,
 			rowYPositions,
 			bidi: block.bidi === true,
 			columnsPinned,
-			cellGrid
+			cellGrid,
+			cellPlacements
 		});
 		tableEl.append(rowEl);
 		y += rowMeasure.height;
@@ -320,13 +329,13 @@ function renderCellDiagonalBorder({ border, direction, cellWidth, cellHeight, do
 	}
 	return line;
 }
-function renderTableCell({ cell, cellMeasure, x, rowHeight, borderFlags, columnsPinned, context, doc, contentClip, pageContentPosition }) {
+function renderTableCell({ cell, cellMeasure, x, width, rowHeight, borderFlags, columnsPinned, context, doc, contentClip, pageContentPosition }) {
 	const cellEl = doc.createElement("div");
 	cellEl.className = TABLE_CLASS_NAMES.cell;
 	cellEl.style.position = "absolute";
 	cellEl.style.left = `${x}px`;
 	cellEl.style.top = "0";
-	cellEl.style.width = `${cellMeasure.width}px`;
+	cellEl.style.width = `${width}px`;
 	cellEl.style.height = `${rowHeight}px`;
 	cellEl.style.overflow = "hidden";
 	cellEl.style.boxSizing = "border-box";
@@ -396,7 +405,7 @@ function renderTableCell({ cell, cellMeasure, x, rowHeight, borderFlags, columns
 	const topLeftToBottomRight = renderCellDiagonalBorder({
 		border: cell.borders?.topLeftToBottomRight,
 		direction: "top-left-to-bottom-right",
-		cellWidth: cellMeasure.width,
+		cellWidth: width,
 		cellHeight: rowHeight,
 		doc
 	});
@@ -404,7 +413,7 @@ function renderTableCell({ cell, cellMeasure, x, rowHeight, borderFlags, columns
 	const topRightToBottomLeft = renderCellDiagonalBorder({
 		border: cell.borders?.topRightToBottomLeft,
 		direction: "top-right-to-bottom-left",
-		cellWidth: cellMeasure.width,
+		cellWidth: width,
 		cellHeight: rowHeight,
 		doc
 	});
@@ -423,52 +432,23 @@ function renderTableCell({ cell, cellMeasure, x, rowHeight, borderFlags, columns
 	}
 	return cellEl;
 }
-const tableCellGridKey = (rowIndex, columnIndex) => `${rowIndex}:${columnIndex}`;
-function buildTableCellGrid(block, columnCount) {
-	const grid = /* @__PURE__ */ new Map();
-	for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex++) {
-		const row = block.rows[rowIndex];
-		if (!row) continue;
-		let columnIndex = 0;
-		for (const cell of row.cells) {
-			while (grid.has(tableCellGridKey(rowIndex, columnIndex))) columnIndex += 1;
-			const colSpan = cell.colSpan ?? 1;
-			const rowSpan = cell.rowSpan ?? 1;
-			const rowEnd = Math.min(block.rows.length, rowIndex + rowSpan);
-			const columnEnd = Math.min(columnCount, columnIndex + colSpan);
-			for (let gridRow = rowIndex; gridRow < rowEnd; gridRow++) for (let gridColumn = columnIndex; gridColumn < columnEnd; gridColumn++) grid.set(tableCellGridKey(gridRow, gridColumn), cell);
-			columnIndex += colSpan;
-		}
-	}
-	return grid;
-}
 const hasVisibleBorder = (border) => border !== void 0 && border.style !== "none" && border.style !== "nil";
-function renderTableRow({ row, rowMeasure, rowIndex, y, columnWidths, totalRows, context, doc, spanningCells, rowYPositions, isFirstRowInFragment, bidi = false, columnsPinned = false, cellGrid, contentClip, pageContentPosition }) {
+function renderTableRow({ row, rowMeasure, rowIndex, y, columnWidths, totalRows, context, doc, rowYPositions, isFirstRowInFragment, bidi = false, columnsPinned = false, cellGrid, cellPlacements, contentClip, pageContentPosition }) {
 	const rowEl = doc.createElement("div");
 	rowEl.className = TABLE_CLASS_NAMES.row;
-	const tableWidth = bidi ? columnWidths.reduce((sum, columnWidth) => sum + columnWidth, 0) : 0;
 	rowEl.style.position = "absolute";
 	rowEl.style.left = "0";
 	rowEl.style.top = `${y}px`;
 	rowEl.style.width = "100%";
 	rowEl.style.height = `${rowMeasure.height}px`;
 	rowEl.dataset["rowIndex"] = String(rowIndex);
-	const occupiedColumns = /* @__PURE__ */ new Set();
-	if (spanningCells) {
-		for (const [, spanCell] of spanningCells) if (spanCell.startRow < rowIndex && spanCell.startRow + spanCell.rowSpan > rowIndex) for (let c = 0; c < spanCell.colSpan; c++) occupiedColumns.add(spanCell.columnIndex + c);
-	}
-	const gridBefore = row.gridBefore ?? 0;
-	let x = getTableRowLeadingWidth(row, columnWidths);
-	let columnIndex = gridBefore;
-	while (occupiedColumns.has(columnIndex)) {
-		x += columnWidths[columnIndex] ?? 0;
-		columnIndex++;
-	}
 	for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex++) {
 		const cell = row.cells[cellIndex];
 		const cellMeasure = rowMeasure.cells[cellIndex];
 		if (!cell || !cellMeasure) continue;
-		const colSpan = cell.colSpan ?? 1;
+		const placement = cellPlacements.get(cell);
+		if (!placement) continue;
+		const { sourceColumn: columnIndex, columnSpan: colSpan, left: cellLeft, width } = placement;
 		const rowSpan = cell.rowSpan ?? 1;
 		let cellHeight = rowMeasure.height;
 		if (rowSpan > 1 && rowYPositions) {
@@ -476,24 +456,21 @@ function renderTableRow({ row, rowMeasure, rowIndex, y, columnWidths, totalRows,
 			for (let r = rowIndex; r < rowIndex + rowSpan && r < rowYPositions.length - 1; r++) cellHeight += (rowYPositions[r + 1] ?? 0) - (rowYPositions[r] ?? 0);
 			if (cellHeight === 0) cellHeight = rowMeasure.height * rowSpan;
 		}
-		let cellWidth = 0;
-		for (let c = 0; c < colSpan && columnIndex + c < columnWidths.length; c++) cellWidth += columnWidths[columnIndex + c] ?? 0;
-		const cellLeft = bidi ? tableWidth - x - cellWidth : x;
 		const isFirstRow = rowIndex === 0 || isFirstRowInFragment === true;
 		const isLastRow = rowIndex + rowSpan >= totalRows;
 		const atLogicalStart = columnIndex === 0;
 		const atLogicalEnd = columnIndex + colSpan >= columnWidths.length;
 		const isFirstCol = bidi ? atLogicalEnd : atLogicalStart;
 		const isLastCol = bidi ? atLogicalStart : atLogicalEnd;
-		const aboveCell = cellGrid?.get(tableCellGridKey(rowIndex - 1, columnIndex));
-		const leftNeighborColumn = bidi ? columnIndex + colSpan : columnIndex - 1;
-		const leftCell = cellGrid?.get(tableCellGridKey(rowIndex, leftNeighborColumn));
+		const aboveCell = getSourceCellAt(cellGrid, rowIndex - 1, columnIndex);
+		const leftCell = getSourceCellAt(cellGrid, rowIndex, bidi ? columnIndex + colSpan : columnIndex - 1);
 		const drawTop = isFirstRow || !hasVisibleBorder(aboveCell?.borders?.bottom);
 		const drawLeft = isFirstCol || !hasVisibleBorder(leftCell?.borders?.right);
 		const cellEl = renderTableCell({
 			cell,
 			cellMeasure,
 			x: cellLeft,
+			width,
 			rowHeight: cellHeight,
 			borderFlags: {
 				drawTop,
@@ -515,25 +492,6 @@ function renderTableRow({ row, rowMeasure, rowIndex, y, columnWidths, totalRows,
 		cellEl.dataset["columnIndex"] = String(columnIndex);
 		if (rowSpan > 1) cellEl.dataset["rowSpan"] = String(rowSpan);
 		rowEl.append(cellEl);
-		if (rowSpan > 1 && spanningCells) {
-			const key = `${rowIndex}-${columnIndex}`;
-			spanningCells.set(key, {
-				cell,
-				cellMeasure,
-				columnIndex,
-				startRow: rowIndex,
-				rowSpan,
-				colSpan,
-				x: cellLeft,
-				totalHeight: cellHeight
-			});
-		}
-		x += cellWidth;
-		columnIndex += colSpan;
-		while (occupiedColumns.has(columnIndex)) {
-			x += columnWidths[columnIndex] ?? 0;
-			columnIndex++;
-		}
 	}
 	return rowEl;
 }
@@ -592,9 +550,13 @@ function renderTableFragment(fragment, block, measure, context, options = {}) {
 		yPos += i_item.height;
 	}
 	rowYPositions.push(yPos);
-	const spanningCells = /* @__PURE__ */ new Map();
 	const columnsPinned = tableColumnsArePinned(block);
-	const cellGrid = buildTableCellGrid(block, measure.columnWidths.length);
+	const cellGrid = buildTableCellGrid(block.rows, measure.columnWidths.length);
+	const cellPlacements = buildTableCellPlacements({
+		grid: cellGrid,
+		columnWidths: measure.columnWidths,
+		bidi: block.bidi === true
+	});
 	const headerRowCount = fragment.headerRowCount ?? 0;
 	let y = 0;
 	if (headerRowCount > 0 && fragment.continuesFromPrev) for (let hdrIdx = 0; hdrIdx < headerRowCount; hdrIdx++) {
@@ -614,12 +576,12 @@ function renderTableFragment(fragment, block, measure, context, options = {}) {
 			totalRows: block.rows.length,
 			context,
 			doc,
-			spanningCells,
 			rowYPositions,
 			isFirstRowInFragment: hdrIdx === 0,
 			bidi: block.bidi === true,
 			columnsPinned,
 			cellGrid,
+			cellPlacements,
 			...tablePageContentPosition ? { pageContentPosition: {
 				...tablePageContentPosition,
 				y: tablePageContentPosition.y + y
@@ -667,12 +629,12 @@ function renderTableFragment(fragment, block, measure, context, options = {}) {
 			totalRows: block.rows.length,
 			context,
 			doc,
-			spanningCells,
 			rowYPositions,
 			isFirstRowInFragment,
 			bidi: block.bidi === true,
 			columnsPinned,
 			cellGrid,
+			cellPlacements,
 			...contentClip ? { contentClip } : {},
 			...tablePageContentPosition ? { pageContentPosition: {
 				...tablePageContentPosition,

package/dist/prosemirror/conversion/toProseDoc.js

@@ -30,6 +30,11 @@ const createTextBoxGroupIdFactory = () => {
 	let index = 0;
 	return () => `${salt}:${index++}`;
 };
+/** Keep imported hyperlink identity unique across every nested conversion scope. */
+const createHyperlinkInstanceIndexAllocator = () => {
+	let index = 0;
+	return () => index++;
+};
 /**
 * Convert a Document to a ProseMirror document
 *
@@ -42,6 +47,11 @@ function toProseDoc(document, options) {
 	const styleResolver = createStyleEngine(options?.styles ?? document.package.styles);
 	const theme = options?.theme ?? document.package.theme ?? null;
 	const nextTextBoxGroupId = createTextBoxGroupIdFactory();
+	const conversionContext = {
+		theme,
+		nextTextBoxGroupId,
+		nextHyperlinkInstanceIndex: createHyperlinkInstanceIndexAllocator()
+	};
 	const convertBodyBlocks = (blocks) => {
 		const out = [];
 		for (const block of blocks) if (block.type === "paragraph") {
@@ -49,10 +59,7 @@ function toProseDoc(document, options) {
 			if (pbPos === "before") out.push(schema.node("pageBreak"));
 			const converted = convertParagraphWithTextBoxes(block, styleResolver, {
 				textBoxGroupId: nextTextBoxGroupId(),
-				context: {
-					theme,
-					nextTextBoxGroupId
-				}
+				context: conversionContext
 			});
 			const firstConverted = converted.at(0);
 			if (pbPos === "before" && converted.length === 1 && firstConverted?.type.name === "paragraph" && firstConverted.content.size === 0 && document.package.settings?.splitPageBreakAndParagraphMark !== true) {
@@ -72,10 +79,7 @@ function toProseDoc(document, options) {
 			}
 			out.push(...converted);
 			if (pbPos === "after") out.push(schema.node("pageBreak"));
-		} else if (block.type === "table") out.push(convertTable(block, styleResolver, {
-			theme,
-			nextTextBoxGroupId
-		}));
+		} else if (block.type === "table") out.push(convertTable(block, styleResolver, conversionContext));
 		else out.push(convertBlockSdt(block, convertBodyBlocks));
 		return out;
 	};
@@ -122,14 +126,13 @@ function convertBlockSdt(blockSdt, convertBlocks) {
 * Resolves style-based text formatting and passes it to runs so that
 * paragraph styles (like Heading1) apply their font size, color, etc.
 */
-function convertParagraph(paragraph, styleResolver, activeCommentIds, extraRunFormatting, tableParagraphOverlay, textBoxAnchors) {
+function convertParagraph(paragraph, styleResolver, nextHyperlinkInstanceIndex, activeCommentIds, extraRunFormatting, tableParagraphOverlay, textBoxAnchors) {
 	const attrs = paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOverlay);
 	const isTocParagraph = isTocStyleId(paragraph.formatting?.styleId);
 	const inlineNodes = [];
 	let inlineOffset = 0;
 	let bookmarksArr;
 	let emptyHyperlinks;
-	let hyperlinkIndex = 0;
 	const commentIds = activeCommentIds ?? /* @__PURE__ */ new Set();
 	const emitInlineNodes = (nodes) => {
 		if (nodes.length === 0) return;
@@ -160,7 +163,7 @@ function convertParagraph(paragraph, styleResolver, activeCommentIds, extraRunFo
 		return suppressParagraphMarkFormatting(baseRunFormatting, inheritableParagraphRunFormatting, formatting, paragraphMarkPrecedesStyle);
 	};
 	const emitTrackedChange = (change, markType, moveKind) => {
-		emitInlineNodes(convertTrackedChange(change, markType, getInheritedRunFormatting, styleResolver, moveKind, textBoxAnchors));
+		emitInlineNodes(convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, moveKind, textBoxAnchors));
 	};
 	for (const content of paragraph.content) {
 		if (content.type === "commentRangeStart") commentIds.add(content.id);
@@ -168,12 +171,10 @@ function convertParagraph(paragraph, styleResolver, activeCommentIds, extraRunFo
 		else if (content.type === "commentReference") anchorPointComment(inlineNodes, content.id);
 		else if (content.type === "run") emitInlineNodes(convertRun(content, getInheritedRunFormatting(content.formatting), styleResolver, textBoxAnchors));
 		else if (content.type === "hyperlink") {
-			const currentHyperlinkIndex = hyperlinkIndex;
-			hyperlinkIndex += 1;
 			const linkNodes = convertHyperlink(content, {
 				getInheritedRunFormatting,
 				styleResolver,
-				hyperlinkIndex: currentHyperlinkIndex,
+				hyperlinkIndex: nextHyperlinkInstanceIndex(),
 				textBoxAnchors
 			});
 			if (linkNodes.length === 0) {
@@ -189,7 +190,7 @@ function convertParagraph(paragraph, styleResolver, activeCommentIds, extraRunFo
 			}
 			emitInlineNodes(linkNodes);
 		} else if (content.type === "simpleField" || content.type === "complexField") emitInlineNode(convertField(content, getInheritedRunFormatting, styleResolver));
-		else if (content.type === "inlineSdt") emitInlineNode(convertInlineSdt(content, getInheritedRunFormatting, styleResolver, textBoxAnchors));
+		else if (content.type === "inlineSdt") emitInlineNode(convertInlineSdt(content, nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, textBoxAnchors));
 		else if (content.type === "insertion" || content.type === "moveTo") emitTrackedChange(content, "insertion", content.type === "moveTo" ? "moveTo" : null);
 		else if (content.type === "deletion" || content.type === "moveFrom") emitTrackedChange(content, "deletion", content.type === "moveFrom" ? "moveFrom" : null);
 		else if (content.type === "mathEquation") emitInlineNode(convertMathEquation(content));
@@ -243,13 +244,11 @@ function anchorPointComment(nodes, commentId) {
 * Convert tracked change (insertion or deletion) content to PM nodes with
 * an insertion/deletion mark applied.
 */
-function convertTrackedChange(change, markType, getInheritedRunFormatting, styleResolver, moveKind = null, textBoxAnchors) {
+function convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, moveKind = null, textBoxAnchors) {
 	const nodes = [];
-	let hyperlinkIndex = 0;
 	for (const item of change.content) if (item.type === "run") nodes.push(...convertRun(item, getInheritedRunFormatting(item.formatting), styleResolver, textBoxAnchors));
 	else {
-		const currentHyperlinkIndex = hyperlinkIndex;
-		hyperlinkIndex += 1;
+		const currentHyperlinkIndex = nextHyperlinkInstanceIndex();
 		nodes.push(...convertHyperlink(item, {
 			getInheritedRunFormatting,
 			styleResolver,
@@ -921,7 +920,8 @@ function standaloneTableCellToProseMirror(cell, nodeType) {
 		styleResolver: null,
 		context: {
 			theme: null,
-			nextTextBoxGroupId: createTextBoxGroupIdFactory()
+			nextTextBoxGroupId: createTextBoxGroupIdFactory(),
+			nextHyperlinkInstanceIndex: createHyperlinkInstanceIndexAllocator()
 		},
 		isHeader: nodeType === "tableHeader",
 		gridWidthPercent: void 0,
@@ -973,20 +973,17 @@ function convertMathEquation(math) {
 /**
 * Convert an InlineSdt to a ProseMirror sdt node with inline content.
 */
-function convertInlineSdt(sdt, getInheritedRunFormatting, styleResolver, textBoxAnchors) {
+function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, textBoxAnchors) {
 	const props = sdt.properties;
 	const inlineNodes = [];
-	let hyperlinkIndex = 0;
 	for (const content of sdt.content) if (content.type === "run") {
 		const runNodes = convertRun(content, getInheritedRunFormatting(content.formatting), styleResolver, textBoxAnchors);
 		inlineNodes.push(...runNodes);
 	} else if (content.type === "hyperlink") {
-		const currentHyperlinkIndex = hyperlinkIndex;
-		hyperlinkIndex += 1;
 		const linkNodes = convertHyperlink(content, {
 			getInheritedRunFormatting,
 			styleResolver,
-			hyperlinkIndex: currentHyperlinkIndex,
+			hyperlinkIndex: nextHyperlinkInstanceIndex(),
 			textBoxAnchors
 		});
 		inlineNodes.push(...linkNodes);
@@ -994,12 +991,12 @@ function convertInlineSdt(sdt, getInheritedRunFormatting, styleResolver, textBox
 		const fieldNode = convertField(content, getInheritedRunFormatting, styleResolver);
 		if (fieldNode) inlineNodes.push(fieldNode);
 	} else if (content.type === "inlineSdt") {
-		const nestedSdt = convertInlineSdt(content, getInheritedRunFormatting, styleResolver, textBoxAnchors);
+		const nestedSdt = convertInlineSdt(content, nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, textBoxAnchors);
 		if (nestedSdt) inlineNodes.push(nestedSdt);
-	} else if (content.type === "insertion") inlineNodes.push(...convertTrackedChange(content, "insertion", getInheritedRunFormatting, styleResolver, null, textBoxAnchors));
-	else if (content.type === "deletion") inlineNodes.push(...convertTrackedChange(content, "deletion", getInheritedRunFormatting, styleResolver, null, textBoxAnchors));
-	else if (content.type === "moveTo") inlineNodes.push(...convertTrackedChange(content, "insertion", getInheritedRunFormatting, styleResolver, "moveTo", textBoxAnchors));
-	else if (content.type === "moveFrom") inlineNodes.push(...convertTrackedChange(content, "deletion", getInheritedRunFormatting, styleResolver, "moveFrom", textBoxAnchors));
+	} else if (content.type === "insertion") inlineNodes.push(...convertTrackedChange(content, "insertion", nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, null, textBoxAnchors));
+	else if (content.type === "deletion") inlineNodes.push(...convertTrackedChange(content, "deletion", nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, null, textBoxAnchors));
+	else if (content.type === "moveTo") inlineNodes.push(...convertTrackedChange(content, "insertion", nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, "moveTo", textBoxAnchors));
+	else if (content.type === "moveFrom") inlineNodes.push(...convertTrackedChange(content, "deletion", nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, "moveFrom", textBoxAnchors));
 	else {
 		const mathNode = convertMathEquation(content);
 		if (mathNode) inlineNodes.push(mathNode);
@@ -1380,7 +1377,7 @@ function convertShape(shape) {
 }
 function convertParagraphWithTextBoxes(block, styleResolver, { textBoxGroupId, context, extraRunFormatting, tableParagraphOverlay }) {
 	const { textBoxes, textBoxAnchors } = extractTextBoxesFromParagraph(block, textBoxGroupId);
-	const pmParagraph = convertParagraph(block, styleResolver, void 0, extraRunFormatting, tableParagraphOverlay, textBoxAnchors);
+	const pmParagraph = convertParagraph(block, styleResolver, context.nextHyperlinkInstanceIndex, void 0, extraRunFormatting, tableParagraphOverlay, textBoxAnchors);
 	const nodes = [];
 	const isEmptyAfterExtraction = textBoxes.length > 0 && !hasContentBesidesTextBoxAnchors(pmParagraph);
 	const keepWrapperParagraph = isEmptyAfterExtraction && hasParagraphBoundaryPayload(block, pmParagraph);
@@ -1639,19 +1636,18 @@ function headerFooterToProseDoc(content, options) {
 	const styleResolver = options?.styles ? createStyleEngine(options.styles) : null;
 	const theme = options?.theme ?? null;
 	const nextTextBoxGroupId = createTextBoxGroupIdFactory();
+	const conversionContext = {
+		theme,
+		nextTextBoxGroupId,
+		nextHyperlinkInstanceIndex: createHyperlinkInstanceIndexAllocator()
+	};
 	const convertBlocks = (blocks) => {
 		const out = [];
 		for (const block of blocks) if (block.type === "paragraph") out.push(...convertParagraphWithTextBoxes(block, styleResolver, {
 			textBoxGroupId: nextTextBoxGroupId(),
-			context: {
-				theme,
-				nextTextBoxGroupId
-			}
-		}));
-		else if (block.type === "table") out.push(convertTable(block, styleResolver, {
-			theme,
-			nextTextBoxGroupId
+			context: conversionContext
 		}));
+		else if (block.type === "table") out.push(convertTable(block, styleResolver, conversionContext));
 		else out.push(convertBlockSdt(block, convertBlocks));
 		return out;
 	};

package/dist/utils/paragraphInlineLayout.d.ts

@@ -0,0 +1,14 @@
+import { ParagraphAttrs, ParagraphBlock } from "../layout-engine/types.js";
+//#region src/utils/paragraphInlineLayout.d.ts
+type ParagraphAlignment = NonNullable<ParagraphAttrs["alignment"]>;
+type PhysicalParagraphInlineLayout = {
+  alignment: ParagraphAlignment;
+  explicitAlignment?: ParagraphAlignment;
+  indentLeft: number;
+  indentRight: number;
+  isRtl: boolean;
+};
+/** Resolve logical OOXML paragraph sides into physical inline geometry. */
+declare const resolvePhysicalParagraphInlineLayout: (block: ParagraphBlock) => PhysicalParagraphInlineLayout;
+//#endregion
+export { PhysicalParagraphInlineLayout, resolvePhysicalParagraphInlineLayout };

package/dist/utils/paragraphInlineLayout.js

@@ -0,0 +1,25 @@
+import { isRtlParagraph } from "./paragraphBaseDirection.js";
+//#region src/utils/paragraphInlineLayout.ts
+const mirrorHorizontalAlignment = (alignment) => {
+	if (alignment === "left") return "right";
+	if (alignment === "right") return "left";
+	return alignment;
+};
+/** Resolve logical OOXML paragraph sides into physical inline geometry. */
+const resolvePhysicalParagraphInlineLayout = (block) => {
+	const attrs = block.attrs;
+	const isRtl = isRtlParagraph(block);
+	const mirrorsHorizontalSides = attrs?.bidi === true;
+	const explicitAlignment = mirrorsHorizontalSides ? mirrorHorizontalAlignment(attrs?.alignment) : attrs?.alignment;
+	const indentLeft = attrs?.indent?.left ?? 0;
+	const indentRight = attrs?.indent?.right ?? 0;
+	return {
+		alignment: explicitAlignment ?? (isRtl ? "right" : "left"),
+		...explicitAlignment === void 0 ? {} : { explicitAlignment },
+		indentLeft: mirrorsHorizontalSides ? indentRight : indentLeft,
+		indentRight: mirrorsHorizontalSides ? indentLeft : indentRight,
+		isRtl
+	};
+};
+//#endregion
+export { resolvePhysicalParagraphInlineLayout };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/folio-core",
-  "version": "0.25.2",
+  "version": "0.25.3",
   "description": "Headless, framework-neutral core of folio: the OOXML (.docx) parser, document model, ProseMirror integration, and page-layout engine. No React.",
   "keywords": [
     "document-model",