@stll/folio-core 0.25.1 → 0.25.3

package/dist/docx/selectiveXmlPatch.js

@@ -1,3 +1,4 @@
+import { WORDPROCESSINGML_NAMESPACE_URIS, findAttributeByNamespaceUri, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, parseXmlDocument } from "./xmlParser.js";
 //#region src/docx/selectiveXmlPatch.ts
 /**
 * Selective XML Patch Module
@@ -317,6 +318,190 @@ function extractElementByIdAttr(xml, openLiteral, closeTag, idAttr, id) {
 	const offsets = findElementByIdAttr(xml, openLiteral, closeTag, idAttr, id);
 	return offsets ? xml.slice(offsets.start, offsets.end) : null;
 }
+const qualifiedName = (prefix, localName) => prefix.length === 0 ? localName : `${prefix}:${localName}`;
+const collectNoteElementSyntax = (xml, elementName) => {
+	const byId = /* @__PURE__ */ new Map();
+	const root = parseXmlDocument(xml);
+	for (const element of getChildElements(root)) {
+		if (getLocalName(element.name) !== elementName || !WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "")) continue;
+		const idAttribute = findAttributeByNamespaceUri(element, WORDPROCESSINGML_NAMESPACE_URIS, "id");
+		if (!element.name || !idAttribute) continue;
+		const syntax = {
+			elementName: element.name,
+			idAttributeName: idAttribute.name,
+			elementPrefix: getNamespacePrefix(element.name) ?? "",
+			attributePrefix: getNamespacePrefix(idAttribute.name) ?? ""
+		};
+		const entries = byId.get(idAttribute.value);
+		if (entries) entries.push(syntax);
+		else byId.set(idAttribute.value, [syntax]);
+	}
+	return byId;
+};
+const syntaxLiteral = (syntax) => ({
+	openLiteral: `<${syntax.elementName}`,
+	closeTag: `</${syntax.elementName}>`,
+	idAttr: syntax.idAttributeName
+});
+const extractNoteElement = (xml, syntax, id) => {
+	const { openLiteral, closeTag, idAttr } = syntaxLiteral(syntax);
+	return extractElementByIdAttr(xml, openLiteral, closeTag, idAttr, id);
+};
+const findNoteElement = (xml, syntax, id) => {
+	const { openLiteral, closeTag, idAttr } = syntaxLiteral(syntax);
+	return findElementByIdAttr(xml, openLiteral, closeTag, idAttr, id);
+};
+const rewriteWordprocessingPrefixes = (xml, { source, target, sourceXmlnsDeclarations }) => {
+	let rewritten = "";
+	let quote = null;
+	let insideTag = false;
+	for (let index = 0; index < xml.length; index++) {
+		const character = xml[index];
+		if (!insideTag) {
+			rewritten += character;
+			insideTag = character === "<";
+			continue;
+		}
+		if (quote) {
+			rewritten += character;
+			if (character === quote) quote = null;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			rewritten += character;
+			continue;
+		}
+		if (character === ">") {
+			insideTag = false;
+			rewritten += character;
+			continue;
+		}
+		const previous = xml[index - 1];
+		const isElementName = previous === "<" || previous === "/" && xml[index - 2] === "<";
+		const sourcePrefix = isElementName ? source.elementPrefix : source.attributePrefix;
+		if (sourcePrefix.length > 0 && xml.startsWith(`${sourcePrefix}:`, index)) {
+			const targetPrefix = isElementName ? target.elementPrefix : target.attributePrefix;
+			rewritten += targetPrefix.length === 0 ? "" : `${targetPrefix}:`;
+			index += sourcePrefix.length;
+			continue;
+		}
+		rewritten += character;
+	}
+	return withXmlnsDeclarations(rewritten, sourceXmlnsDeclarations);
+};
+const paragraphRanges = (xml, wordPrefix) => {
+	const ranges = [];
+	const paragraphName = qualifiedName(wordPrefix, "p");
+	const openLiteral = `<${paragraphName}`;
+	const closeTag = `</${paragraphName}>`;
+	let pos = 0;
+	while (pos < xml.length) {
+		const start = xml.indexOf(openLiteral, pos);
+		if (start === -1) break;
+		if (!isXmlNameBoundary(xml[start + openLiteral.length])) {
+			pos = start + 1;
+			continue;
+		}
+		const range = scanElementRange(xml, start, openLiteral, closeTag);
+		if (!range) break;
+		ranges.push(range);
+		pos = range.end;
+	}
+	return ranges;
+};
+const collectChangedNoteParaIds = (baselineXml, currentXml) => {
+	const changed = /* @__PURE__ */ new Set();
+	const baselineIds = collectParaIds(baselineXml);
+	const baselineOffsets = buildParagraphOffsetIndex(baselineXml);
+	const currentOffsets = buildParagraphOffsetIndex(currentXml);
+	for (const [id, count] of collectParaIds(currentXml)) {
+		if (count !== 1 || baselineIds.get(id) !== 1) continue;
+		const before = baselineOffsets.get(id);
+		const after = currentOffsets.get(id);
+		if (before && after && baselineXml.slice(before.start, before.end) !== currentXml.slice(after.start, after.end)) changed.add(id);
+	}
+	return changed;
+};
+const replaceRanges = (xml, replacements) => {
+	let result = xml;
+	for (const { start, end, newXml } of [...replacements].toSorted((a, b) => b.start - a.start)) result = result.slice(0, start) + newXml + result.slice(end);
+	return result;
+};
+/**
+* Patch an existing note part from its model serialization.
+*
+* Dirty paragraph ids locate their owning note in the model serialization;
+* `(note w:id, paragraph ordinal)` then locates the corresponding source XML
+* even when the producer omitted paragraph ids. Equal-shape edits replace only
+* dirty paragraphs. A tracked paragraph-break resolution can change that
+* shape, so it replaces the one affected note. Separator notes, unrelated
+* notes, and unaffected equal-shape paragraphs remain byte-exact.
+* `replacementXml` also supplies synthesized automatic note-reference marks,
+* which the parsed model intentionally omits.
+*/
+function buildPatchedNotePartXml({ originalXml, baselineXml, serializedXml, replacementXml, elementName, changedParaIds }) {
+	const currentElements = collectNoteElementSyntax(serializedXml, elementName);
+	const originalElements = collectNoteElementSyntax(originalXml, elementName);
+	const replacementElements = collectNoteElementSyntax(replacementXml, elementName);
+	const replacementXmlnsDeclarations = collectXmlnsFromOpeningTag(replacementXml);
+	const ordinalReplacements = [];
+	const serializedParaIds = collectParaIds(serializedXml);
+	const effectiveChangedParaIds = changedParaIds ?? collectChangedNoteParaIds(baselineXml, serializedXml);
+	const unroutedChangedParaIds = new Set([...effectiveChangedParaIds].filter((paraId) => serializedParaIds.has(paraId)));
+	for (const [id, currentSyntaxEntries] of currentElements) {
+		const originalSyntaxEntries = originalElements.get(id);
+		const replacementSyntaxEntries = replacementElements.get(id);
+		if (currentSyntaxEntries.length !== 1 || originalSyntaxEntries?.length !== 1 || replacementSyntaxEntries?.length !== 1) return null;
+		const currentSyntax = currentSyntaxEntries[0];
+		const originalSyntax = originalSyntaxEntries[0];
+		const replacementSyntax = replacementSyntaxEntries[0];
+		if (!currentSyntax || !originalSyntax || !replacementSyntax) return null;
+		const currentNote = extractNoteElement(serializedXml, currentSyntax, id);
+		const originalOffsets = findNoteElement(originalXml, originalSyntax, id);
+		const replacementNote = extractNoteElement(replacementXml, replacementSyntax, id);
+		if (!currentNote || !originalOffsets || !replacementNote) return null;
+		const originalNote = originalXml.slice(originalOffsets.start, originalOffsets.end);
+		const currentParagraphs = paragraphRanges(currentNote, currentSyntax.elementPrefix);
+		const originalParagraphs = paragraphRanges(originalNote, originalSyntax.elementPrefix);
+		const replacementParagraphs = paragraphRanges(replacementNote, replacementSyntax.elementPrefix);
+		const noteChangedParaIds = [...collectParaIds(currentNote).keys()].filter((paraId) => unroutedChangedParaIds.has(paraId));
+		if (noteChangedParaIds.length === 0) continue;
+		if (currentParagraphs.length !== originalParagraphs.length || currentParagraphs.length !== replacementParagraphs.length) {
+			for (const paraId of noteChangedParaIds) unroutedChangedParaIds.delete(paraId);
+			ordinalReplacements.push({
+				start: originalOffsets.start,
+				end: originalOffsets.end,
+				newXml: rewriteWordprocessingPrefixes(replacementNote, {
+					source: replacementSyntax,
+					target: originalSyntax,
+					sourceXmlnsDeclarations: replacementXmlnsDeclarations
+				})
+			});
+			continue;
+		}
+		for (let index = 0; index < currentParagraphs.length; index++) {
+			const currentRange = currentParagraphs[index];
+			const originalRange = originalParagraphs[index];
+			const replacementRange = replacementParagraphs[index];
+			if (!currentRange || !originalRange || !replacementRange) return null;
+			const routedIds = [...collectParaIds(currentNote.slice(currentRange.start, currentRange.end)).keys()].filter((paraId) => unroutedChangedParaIds.has(paraId));
+			if (routedIds.length === 0) continue;
+			for (const paraId of routedIds) unroutedChangedParaIds.delete(paraId);
+			ordinalReplacements.push({
+				start: originalOffsets.start + originalRange.start,
+				end: originalOffsets.start + originalRange.end,
+				newXml: rewriteWordprocessingPrefixes(replacementNote.slice(replacementRange.start, replacementRange.end), {
+					source: replacementSyntax,
+					target: originalSyntax,
+					sourceXmlnsDeclarations: replacementXmlnsDeclarations
+				})
+			});
+		}
+	}
+	if (unroutedChangedParaIds.size > 0) return null;
+	return replaceRanges(originalXml, ordinalReplacements);
+}
 /**
 * The full range of the first `<openLiteral …>…</closeTag>` element, or null.
 * Used to locate an unkeyed sub-element (a level's `mc:AlternateContent`).
@@ -627,4 +812,4 @@ function escapeRegExp(str) {
 	return str.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
 //#endregion
-export { appendNumberingDefs, buildParagraphOffsetIndex, buildPatchedDocumentXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectAddedNumberingDefs, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, isXmlNameBoundary, validatePatchSafety };
+export { appendNumberingDefs, buildParagraphOffsetIndex, buildPatchedDocumentXml, buildPatchedNotePartXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectAddedNumberingDefs, collectChangedNoteParaIds, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, isXmlNameBoundary, validatePatchSafety };

package/dist/docx/xmlParser.d.ts

@@ -104,6 +104,12 @@ declare const WORDPROCESSINGML_NAMESPACE_URIS: ReadonlySet<string>;
  * from a foreign namespace is not accepted.
  */
 declare function findChildByNamespaceUri(parent: XmlElement | null | undefined, namespaceUris: ReadonlySet<string>, localName: string): XmlElement | null;
+type XmlAttributeMatch = {
+  name: string;
+  value: string;
+};
+/** Find an attribute whose prefix resolves to one of the accepted namespace URIs. */
+declare function findAttributeByNamespaceUri(element: XmlElement | null | undefined, namespaceUris: ReadonlySet<string>, localName: string): XmlAttributeMatch | null;
 /** Get an attribute whose prefix resolves to one of the accepted namespace URIs. */
 declare function getAttributeByNamespaceUri(element: XmlElement | null | undefined, namespaceUris: ReadonlySet<string>, localName: string): string | null;
 /**
@@ -338,4 +344,4 @@ declare function mergeXmlnsDeclarations(inherited: Record<string, string>, eleme
  */
 declare function cloneWithXmlnsDeclarations(element: XmlElement, xmlnsDecls: Record<string, string>): XmlElement;
 //#endregion
-export { NAMESPACES, WORDPROCESSINGML_NAMESPACE_URIS, XmlElement, XmlNamespaceScope, cloneWithXmlnsDeclarations, collectXmlnsDeclarations, elementToXml, findAllDeep, findByFullName, findChild, findChildByLocalName, findChildByNamespaceUri, findChildren, findChildrenByLocalName, findDeep, getAttribute, getAttributeAny, getAttributeAnyPrefix, getAttributeByNamespaceUri, getAttributes, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, getTextContent, hasChild, hasFlag, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseColorElement, parseNumberingLevelAttribute, parseNumericAttribute, parseOnOffValue, parseTableMeasurementValue, parseXml, parseXmlDocument };
+export { NAMESPACES, WORDPROCESSINGML_NAMESPACE_URIS, XmlAttributeMatch, XmlElement, XmlNamespaceScope, cloneWithXmlnsDeclarations, collectXmlnsDeclarations, elementToXml, findAllDeep, findAttributeByNamespaceUri, findByFullName, findChild, findChildByLocalName, findChildByNamespaceUri, findChildren, findChildrenByLocalName, findDeep, getAttribute, getAttributeAny, getAttributeAnyPrefix, getAttributeByNamespaceUri, getAttributes, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, getTextContent, hasChild, hasFlag, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseColorElement, parseNumberingLevelAttribute, parseNumericAttribute, parseOnOffValue, parseTableMeasurementValue, parseXml, parseXmlDocument };

package/dist/docx/xmlParser.js

@@ -208,16 +208,23 @@ function findChildByNamespaceUri(parent, namespaceUris, localName) {
 	for (const child of parent.elements) if (child.type === "element" && hasLocalName(child.name, localName) && namespaceUris.has(child.namespaceUri ?? "")) return child;
 	return null;
 }
-/** Get an attribute whose prefix resolves to one of the accepted namespace URIs. */
-function getAttributeByNamespaceUri(element, namespaceUris, localName) {
+/** Find an attribute whose prefix resolves to one of the accepted namespace URIs. */
+function findAttributeByNamespaceUri(element, namespaceUris, localName) {
 	if (!element?.attributes) return null;
 	for (const [name, value] of Object.entries(element.attributes)) {
 		if (value === void 0 || getLocalName(name) !== localName) continue;
 		const prefix = getNamespacePrefix(name);
-		if (prefix !== null && namespaceUris.has(resolveNamespaceUri(element.namespaceScope, prefix) ?? "")) return String(value);
+		if (prefix !== null && namespaceUris.has(resolveNamespaceUri(element.namespaceScope, prefix) ?? "")) return {
+			name,
+			value: String(value)
+		};
 	}
 	return null;
 }
+/** Get an attribute whose prefix resolves to one of the accepted namespace URIs. */
+function getAttributeByNamespaceUri(element, namespaceUris, localName) {
+	return findAttributeByNamespaceUri(element, namespaceUris, localName)?.value ?? null;
+}
 function hasLocalName(name, localName) {
 	if (!name) return false;
 	if (name === localName) return true;
@@ -712,4 +719,4 @@ function cloneWithXmlnsDeclarations(element, xmlnsDecls) {
 	return element;
 }
 //#endregion
-export { NAMESPACES, WORDPROCESSINGML_NAMESPACE_URIS, cloneWithXmlnsDeclarations, collectXmlnsDeclarations, elementToXml, findAllDeep, findByFullName, findChild, findChildByLocalName, findChildByNamespaceUri, findChildren, findChildrenByLocalName, findDeep, getAttribute, getAttributeAny, getAttributeAnyPrefix, getAttributeByNamespaceUri, getAttributes, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, getTextContent, hasChild, hasFlag, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseColorElement, parseNumberingLevelAttribute, parseNumericAttribute, parseOnOffValue, parseTableMeasurementValue, parseXml, parseXmlDocument };
+export { NAMESPACES, WORDPROCESSINGML_NAMESPACE_URIS, cloneWithXmlnsDeclarations, collectXmlnsDeclarations, elementToXml, findAllDeep, findAttributeByNamespaceUri, findByFullName, findChild, findChildByLocalName, findChildByNamespaceUri, findChildren, findChildrenByLocalName, findDeep, getAttribute, getAttributeAny, getAttributeAnyPrefix, getAttributeByNamespaceUri, getAttributes, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, getTextContent, hasChild, hasFlag, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseColorElement, parseNumberingLevelAttribute, parseNumericAttribute, parseOnOffValue, parseTableMeasurementValue, parseXml, parseXmlDocument };

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 };