@stll/folio-core 0.0.1-placeholder.0 → 0.1.1

package/dist/layout-bridge/dom/findHfPmSpans.js

@@ -0,0 +1,197 @@
+import { findPositionInSpan } from "./clickToPositionDom.js";
+//#region src/layout-bridge/dom/findHfPmSpans.ts
+/**
+* Slot-scoped sibling of `findBodyPmSpans` — locates `data-pm-start` markers
+* inside a single painted header/footer slot. The pointer pipeline uses these
+* to translate a click coordinate inside `.layout-page-header[data-rid="…"]`
+* (or footer) to a PM position on the matching hidden HF EditorView.
+*
+* Slot identity is the part-relationship id (`rId`) emitted by the painter on
+* the HF DOM node — never the `(hdrFtrType, kind)` tuple (two sections that
+* share a header by rId share both the painted spans and the EditorView).
+*/
+function slotSelector(kind, rId) {
+	return kind === "header" ? `.layout-page-header[data-rid="${rId}"]` : `.layout-page-footer[data-rid="${rId}"]`;
+}
+function associatedSlotSelector(kind, rId) {
+	return `[data-hf-slot-kind="${kind}"][data-hf-rid="${rId}"]`;
+}
+function uniqueElements(elements) {
+	return Array.from(new Set(elements));
+}
+function querySlotDescendants(container, kind, rId, selector) {
+	return uniqueElements([...Array.from(container.querySelectorAll(`${slotSelector(kind, rId)} ${selector}`)), ...Array.from(container.querySelectorAll(`${associatedSlotSelector(kind, rId)} ${selector}`))]);
+}
+function querySlotAnchors(container, kind, rId, selector) {
+	return uniqueElements([...querySlotDescendants(container, kind, rId, selector), ...Array.from(container.querySelectorAll(`${associatedSlotSelector(kind, rId)}${selector}`))]);
+}
+function findHfPmSpans(container, kind, rId) {
+	return querySlotDescendants(container, kind, rId, "span[data-pm-start][data-pm-end]");
+}
+function findHfPmAnchors(container, kind, rId) {
+	return querySlotAnchors(container, kind, rId, "[data-pm-start]");
+}
+function findHfPmAnchor(container, kind, rId, pmStart) {
+	if (!Number.isFinite(pmStart)) return null;
+	return container.querySelector(`${slotSelector(kind, rId)} [data-pm-start="${String(pmStart)}"]`) ?? container.querySelector(`${associatedSlotSelector(kind, rId)} [data-pm-start="${String(pmStart)}"]`) ?? container.querySelector(`${associatedSlotSelector(kind, rId)}[data-pm-start="${String(pmStart)}"]`);
+}
+function findHfCaretSpan(container, kind, rId, pos) {
+	if (!Number.isFinite(pos)) return null;
+	const exact = findHfPmAnchor(container, kind, rId, pos);
+	if (exact) return {
+		element: exact,
+		edge: "left"
+	};
+	const spans = findHfPmSpans(container, kind, rId);
+	let best = null;
+	for (const span of spans) {
+		const startStr = span.dataset["pmStart"];
+		const endStr = span.dataset["pmEnd"];
+		if (startStr === void 0 || endStr === void 0) continue;
+		const start = Number.parseInt(startStr, 10);
+		const end = Number.parseInt(endStr, 10);
+		if (!Number.isFinite(start) || !Number.isFinite(end)) continue;
+		if (pos === end) best = {
+			element: span,
+			edge: "right"
+		};
+		else if (pos > start && pos < end && !best) best = {
+			element: span,
+			edge: "left"
+		};
+	}
+	return best;
+}
+function hasCloset(value) {
+	return typeof value === "object" && value !== null && typeof value.closest === "function";
+}
+/**
+* Slot-scoped click-to-position mapper. `clickToPositionDom`'s fallback
+* (`findNearestSpan`) is hardcoded to `.layout-page-content` — body — so when
+* the user clicks HF whitespace (right of the text, between lines, etc.),
+* the body fallback can return a body PM position that the HF dispatch then
+* applies to the HF EditorView (clamped) and the caret leaps to an
+* unrelated HF doc position (Codex #487 P2: 21:02 review).
+*
+* Scope everything to the slot element: try the exact-span lookup via
+* `document.elementsFromPoint` filtered to descendants of `slot`; fall back
+* to nearest-span-in-line + start/end edge math within the same slot.
+*/
+function clickToPositionInHfSlot(container, kind, rId, clientX, clientY) {
+	const elements = (container instanceof Element ? container.ownerDocument : document).elementsFromPoint(clientX, clientY);
+	for (const el of elements) {
+		if (!(el instanceof HTMLElement)) continue;
+		const slot = findHfSlotForTarget(el);
+		if (!slot || slot.kind !== kind || slot.rId !== rId) continue;
+		if (el.tagName === "SPAN" && el.dataset["pmStart"] !== void 0 && el.dataset["pmEnd"] !== void 0) return findPositionInSpan(el, clientX, clientY);
+	}
+	return findNearestSpanInHfSlots(container, kind, rId, clientX, clientY);
+}
+function computeColDist(inside, rect, clientX) {
+	if (inside) return 0;
+	if (clientX < rect.left) return rect.left - clientX;
+	return clientX - rect.right;
+}
+function findNearestSpanInHfSlots(container, kind, rId, clientX, clientY) {
+	const spans = findHfPmSpans(container, kind, rId);
+	if (spans.length === 0) return null;
+	let bestSpan = null;
+	let bestRowDist = Number.POSITIVE_INFINITY;
+	let bestColDist = Number.POSITIVE_INFINITY;
+	let bestInside = false;
+	for (const span of spans) {
+		const rect = span.getBoundingClientRect();
+		const centerY = (rect.top + rect.bottom) / 2;
+		const rowDist = Math.abs(clientY - centerY);
+		const inside = clientX >= rect.left && clientX <= rect.right;
+		const colDist = computeColDist(inside, rect, clientX);
+		if (rowDist < bestRowDist || rowDist === bestRowDist && (inside && !bestInside || inside === bestInside && colDist < bestColDist)) {
+			bestRowDist = rowDist;
+			bestColDist = colDist;
+			bestInside = inside;
+			bestSpan = span;
+		}
+	}
+	if (!bestSpan) return null;
+	if (bestInside) return findPositionInSpan(bestSpan, clientX, clientY);
+	if (clientX < bestSpan.getBoundingClientRect().left) {
+		const v = bestSpan.dataset["pmStart"];
+		return v ? Number(v) : null;
+	}
+	const v = bestSpan.dataset["pmEnd"];
+	return v ? Number(v) : null;
+}
+function findHfSlotForTarget(target) {
+	if (!target) return null;
+	if (!hasCloset(target)) {
+		const owner = target.parentElement;
+		if (!owner) return null;
+		return findHfSlotForTarget(owner);
+	}
+	const header = target.closest(".layout-page-header[data-rid]");
+	if (header) {
+		const rId = header.dataset["rid"];
+		if (rId) return {
+			kind: "header",
+			rId,
+			element: header
+		};
+	}
+	const footer = target.closest(".layout-page-footer[data-rid]");
+	if (footer) {
+		const rId = footer.dataset["rid"];
+		if (rId) return {
+			kind: "footer",
+			rId,
+			element: footer
+		};
+	}
+	const associated = target.closest("[data-hf-slot-kind][data-hf-rid]");
+	if (associated) {
+		const kind = associated.dataset["hfSlotKind"];
+		const rId = associated.dataset["hfRid"];
+		if ((kind === "header" || kind === "footer") && rId) return {
+			kind,
+			rId,
+			element: associated
+		};
+	}
+	return null;
+}
+/**
+* Resolve only the header/footer KIND of the slot under `target`, whether or
+* not it has an assigned rId yet. `findHfSlotForTarget` matches only a slot
+* that already carries a `data-rid` (an existing HF part); but the painter also
+* renders an EMPTY `.layout-page-header` / `.layout-page-footer` box — the
+* hover-hint and double-click-to-add target — that has no rId. Entering edit
+* mode to *create* a header needs only the kind (the handler mints the part),
+* so this looser resolver matches that empty box too.
+*/
+function findHfSlotKindForTarget(target) {
+	if (!target) return null;
+	if (!hasCloset(target)) {
+		const owner = target.parentElement;
+		return owner ? findHfSlotKindForTarget(owner) : null;
+	}
+	const header = target.closest(".layout-page-header");
+	if (header) return {
+		kind: "header",
+		element: header
+	};
+	const footer = target.closest(".layout-page-footer");
+	if (footer) return {
+		kind: "footer",
+		element: footer
+	};
+	const associated = target.closest("[data-hf-slot-kind]");
+	if (associated) {
+		const kind = associated.dataset["hfSlotKind"];
+		if (kind === "header" || kind === "footer") return {
+			kind,
+			element: associated
+		};
+	}
+	return null;
+}
+//#endregion
+export { clickToPositionInHfSlot, findHfCaretSpan, findHfPmAnchor, findHfPmAnchors, findHfPmSpans, findHfSlotForTarget, findHfSlotKindForTarget };

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

@@ -0,0 +1,66 @@
+import { ParagraphBlock, ParagraphMeasure } from "../../layout-engine/types.js";
+import { FragmentHit, TableCellHit } from "./hitTest.js";
+
+//#region src/layout-bridge/engine/clickToPosition.d.ts
+/**
+ * Result of click-to-position mapping.
+ */
+type PositionResult = {
+  /** ProseMirror document position. */pmPosition: number; /** Character offset within the line (for debugging). */
+  charOffset: number; /** Line index within the paragraph. */
+  lineIndex: number;
+};
+/**
+ * A click in the second half of an astral glyph can resolve to the UTF-16
+ * offset between its surrogate pair (`measureRun` emits a 0-width entry for the
+ * trailing surrogate). Nudge such an offset forward to the code-point boundary
+ * so ProseMirror never receives — or edits inside — a half-pair position.
+ */
+declare function snapPastTrailingSurrogate(text: string, offset: number): number;
+/**
+ * Map a click within a paragraph fragment to a PM position.
+ *
+ * @param fragmentHit - The fragment hit result from hitTestFragment.
+ * @returns Position result, or null if mapping fails.
+ */
+declare function clickToPositionInParagraph(fragmentHit: FragmentHit): PositionResult | null;
+/**
+ * Map a click within a table cell to a PM position.
+ *
+ * @param tableCellHit - The table cell hit result from hitTestTableCell.
+ * @returns PM position, or null if mapping fails.
+ */
+declare function clickToPositionInTableCell(tableCellHit: TableCellHit): number | null;
+/**
+ * Main entry point: Map a click to a PM position.
+ *
+ * This function takes the result of hit testing and returns the PM position.
+ *
+ * @param fragmentHit - Fragment hit from hitTestFragment.
+ * @param tableCellHit - Optional table cell hit from hitTestTableCell.
+ * @returns PM position, or null if mapping fails.
+ */
+declare function clickToPosition(fragmentHit: FragmentHit | null, tableCellHit?: TableCellHit | null): number | null;
+/**
+ * Map a PM position to X coordinates within a line (for caret positioning).
+ *
+ * @param block - The paragraph block.
+ * @param measure - The paragraph measure.
+ * @param pmPosition - The PM position to map.
+ * @param fragmentWidth - Width of the fragment.
+ * @returns X coordinate relative to fragment start, or null if not found.
+ */
+declare function positionToX(block: ParagraphBlock, measure: ParagraphMeasure, pmPosition: number, _fragmentWidth: number): {
+  x: number;
+  lineIndex: number;
+} | null;
+/**
+ * Get the bounding rect for a PM position (for caret rendering).
+ */
+declare function getPositionRect(block: ParagraphBlock, measure: ParagraphMeasure, pmPosition: number, fragmentX: number, fragmentY: number, fragmentWidth: number, fromLine: number): {
+  x: number;
+  y: number;
+  height: number;
+} | null;
+//#endregion
+export { PositionResult, clickToPosition, clickToPositionInParagraph, clickToPositionInTableCell, getPositionRect, positionToX, snapPastTrailingSurrogate };

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

@@ -0,0 +1,403 @@
+import { measureRun } from "../../layout-engine/measure/measureProvider.js";
+import { buildRunFontStyle, findCharacterAtX } from "../../layout-engine/measure/measureHelpers.js";
+import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
+import { measuredLineAdvance, measuredLineContentOffset } from "../../layout-engine/lineFlow.js";
+//#region src/layout-bridge/engine/clickToPosition.ts
+/**
+* Click-to-Position Mapping
+*
+* Maps click coordinates within a layout to ProseMirror document positions.
+* Uses geometry-based calculation with canvas text measurement for accuracy.
+*
+* The main entry point `clickToPosition` takes fragment hit data and local
+* coordinates and returns the PM position at the click point.
+*/
+/**
+* Extract FontStyle from a run for measurement.
+*/
+function runToFontStyle(run) {
+	return buildRunFontStyle(run, "Arial", 12);
+}
+/**
+* A click in the second half of an astral glyph can resolve to the UTF-16
+* offset between its surrogate pair (`measureRun` emits a 0-width entry for the
+* trailing surrogate). Nudge such an offset forward to the code-point boundary
+* so ProseMirror never receives — or edits inside — a half-pair position.
+*/
+function snapPastTrailingSurrogate(text, offset) {
+	const codeUnit = offset < text.length ? text.codePointAt(offset) : void 0;
+	if (codeUnit !== void 0 && codeUnit >= 56320 && codeUnit <= 57343) return offset + 1;
+	return offset;
+}
+/**
+* Slice the runs that are part of a specific line.
+* Returns only the text portions that belong to the line.
+*/
+function sliceRunsForLine(block, line) {
+	const result = [];
+	for (let runIndex = line.fromRun; runIndex <= line.toRun && runIndex < block.runs.length; runIndex++) {
+		const run = block.runs[runIndex];
+		if (!run) continue;
+		if (run.kind === "tab" || run.kind === "image" || run.kind === "lineBreak") {
+			result.push(run);
+			continue;
+		}
+		if (run.kind === "text") {
+			const text = run.text;
+			const isFirstRun = runIndex === line.fromRun;
+			const isLastRun = runIndex === line.toRun;
+			if (isFirstRun || isLastRun) {
+				const start = isFirstRun ? line.fromChar : 0;
+				const end = isLastRun ? line.toChar : text.length;
+				const slice = text.slice(start, end);
+				if (slice.length > 0) result.push({
+					...run,
+					text: slice
+				});
+			} else result.push(run);
+		}
+	}
+	return result;
+}
+/**
+* Calculate the PM position range for a line.
+*/
+function computeLinePmRange(block, line) {
+	let pmStart;
+	let pmEnd;
+	const blockPmStart = block.pmStart ?? 0;
+	let charOffset = 0;
+	for (let runIndex = 0; runIndex < block.runs.length && runIndex <= line.toRun; runIndex++) {
+		const run = block.runs[runIndex];
+		if (!run) continue;
+		if (runIndex < line.fromRun) {
+			if (run.kind === "text") charOffset += run.text.length;
+			else if (run.kind === "tab" || run.kind === "lineBreak") charOffset += 1;
+			else if (run.kind === "image") charOffset += 1;
+		} else if (runIndex === line.fromRun) {
+			charOffset += line.fromChar;
+			pmStart = blockPmStart + charOffset;
+			if (run.kind === "text") charOffset = line.fromChar;
+		}
+	}
+	if (pmStart !== void 0) {
+		let lineLength = 0;
+		for (let runIndex = line.fromRun; runIndex <= line.toRun && runIndex < block.runs.length; runIndex++) {
+			const run = block.runs[runIndex];
+			if (!run) continue;
+			if (run.kind === "text") {
+				const text = run.text;
+				const start = runIndex === line.fromRun ? line.fromChar : 0;
+				const end = runIndex === line.toRun ? line.toChar : text.length;
+				lineLength += end - start;
+			} else if (run.kind === "tab" || run.kind === "lineBreak") lineLength += 1;
+			else if (run.kind === "image") lineLength += 1;
+		}
+		pmEnd = pmStart + lineLength;
+	}
+	return {
+		pmStart,
+		pmEnd
+	};
+}
+/**
+* Find which line contains a Y coordinate within a fragment.
+*
+* @param measure - The paragraph measure with lines.
+* @param localY - Y coordinate relative to fragment top.
+* @param fromLine - First line index in the fragment.
+* @param toLine - Last line index (exclusive) in the fragment.
+* @returns Line index, or null if not found.
+*/
+function findLineAtY(measure, localY, fromLine, toLine) {
+	let y = 0;
+	for (let lineIndex = fromLine; lineIndex < toLine && lineIndex < measure.lines.length; lineIndex++) {
+		const line = measure.lines[lineIndex];
+		const lineAdvance = measuredLineAdvance(line);
+		if (localY >= y && localY < y + lineAdvance) return lineIndex;
+		y += lineAdvance;
+	}
+	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) {
+	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);
+	const adjustedX = Math.max(0, x - alignmentOffset);
+	if (adjustedX <= 0) return {
+		charOffset: 0,
+		pmPosition: pmStart
+	};
+	const runs = sliceRunsForLine(block, line);
+	if (runs.length === 0) return {
+		charOffset: 0,
+		pmPosition: pmStart
+	};
+	let currentX = 0;
+	let currentCharOffset = 0;
+	for (const run of runs) {
+		if (run.kind === "tab") {
+			const tabWidth = run.width ?? 48;
+			const runEndX = currentX + tabWidth;
+			if (adjustedX <= runEndX) {
+				if (adjustedX < currentX + tabWidth / 2) return {
+					charOffset: currentCharOffset,
+					pmPosition: pmStart + currentCharOffset
+				};
+				return {
+					charOffset: currentCharOffset + 1,
+					pmPosition: pmStart + currentCharOffset + 1
+				};
+			}
+			currentX = runEndX;
+			currentCharOffset += 1;
+			continue;
+		}
+		if (run.kind === "image") {
+			const imageWidth = inlineImageBoundingBox(run).width;
+			const runEndX = currentX + imageWidth;
+			if (adjustedX <= runEndX) {
+				if (adjustedX < currentX + imageWidth / 2) return {
+					charOffset: currentCharOffset,
+					pmPosition: pmStart + currentCharOffset
+				};
+				return {
+					charOffset: currentCharOffset + 1,
+					pmPosition: pmStart + currentCharOffset + 1
+				};
+			}
+			currentX = runEndX;
+			currentCharOffset += 1;
+			continue;
+		}
+		if (run.kind === "lineBreak") {
+			if (adjustedX >= currentX) return {
+				charOffset: currentCharOffset,
+				pmPosition: pmStart + currentCharOffset
+			};
+			currentCharOffset += 1;
+			continue;
+		}
+		if (run.kind === "text") {
+			const text = run.text;
+			if (text.length === 0) continue;
+			const measurement = measureRun(text, runToFontStyle(run));
+			const runEndX = currentX + measurement.width;
+			if (adjustedX <= runEndX) {
+				const charInRun = snapPastTrailingSurrogate(text, findCharacterAtX(adjustedX - currentX, measurement.charWidths));
+				const charOffset = currentCharOffset + charInRun;
+				return {
+					charOffset,
+					pmPosition: pmStart + charOffset
+				};
+			}
+			currentX = runEndX;
+			currentCharOffset += text.length;
+		}
+	}
+	return {
+		charOffset: pmEnd - pmStart,
+		pmPosition: pmEnd
+	};
+}
+/**
+* Map a click within a paragraph fragment to a PM position.
+*
+* @param fragmentHit - The fragment hit result from hitTestFragment.
+* @returns Position result, or null if mapping fails.
+*/
+function clickToPositionInParagraph(fragmentHit) {
+	const { fragment, block, measure, localX, localY } = fragmentHit;
+	if (fragment.kind !== "paragraph") return null;
+	if (block.kind !== "paragraph") return null;
+	if (measure.kind !== "paragraph") return null;
+	const paragraphFragment = fragment;
+	const paragraphBlock = block;
+	const paragraphMeasure = measure;
+	const lineIndex = findLineAtY(paragraphMeasure, localY, paragraphFragment.fromLine, paragraphFragment.toLine);
+	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 availableWidth = Math.max(0, fragment.width - indentLeft - indentRight);
+	const { charOffset, pmPosition } = findCharacterInLine(paragraphBlock, line, localX - indentLeft, availableWidth);
+	return {
+		pmPosition,
+		charOffset,
+		lineIndex
+	};
+}
+/**
+* Map a click within a table cell to a PM position.
+*
+* @param tableCellHit - The table cell hit result from hitTestTableCell.
+* @returns PM position, or null if mapping fails.
+*/
+function clickToPositionInTableCell(tableCellHit) {
+	const { cellBlock, cellMeasure, cellLocalX, cellLocalY } = tableCellHit;
+	if (!cellBlock || !cellMeasure) return null;
+	return clickToPositionInParagraph({
+		fragment: {
+			kind: "paragraph",
+			blockId: cellBlock.id,
+			x: 0,
+			y: 0,
+			width: getMaxLineWidth(cellMeasure.lines, 100),
+			fromLine: 0,
+			toLine: cellMeasure.lines.length,
+			height: cellMeasure.totalHeight
+		},
+		block: cellBlock,
+		measure: cellMeasure,
+		pageIndex: tableCellHit.pageIndex,
+		localX: cellLocalX,
+		localY: cellLocalY
+	})?.pmPosition ?? null;
+}
+/**
+* Main entry point: Map a click to a PM position.
+*
+* This function takes the result of hit testing and returns the PM position.
+*
+* @param fragmentHit - Fragment hit from hitTestFragment.
+* @param tableCellHit - Optional table cell hit from hitTestTableCell.
+* @returns PM position, or null if mapping fails.
+*/
+function clickToPosition(fragmentHit, tableCellHit) {
+	if (tableCellHit) return clickToPositionInTableCell(tableCellHit);
+	if (!fragmentHit) return null;
+	const { fragment } = fragmentHit;
+	if (fragment.kind === "paragraph") return clickToPositionInParagraph(fragmentHit)?.pmPosition ?? null;
+	if (fragment.kind === "image") return fragment.pmStart ?? null;
+	return null;
+}
+/**
+* Map a PM position to X coordinates within a line (for caret positioning).
+*
+* @param block - The paragraph block.
+* @param measure - The paragraph measure.
+* @param pmPosition - The PM position to map.
+* @param fragmentWidth - Width of the fragment.
+* @returns X coordinate relative to fragment start, or null if not found.
+*/
+function positionToX(block, measure, pmPosition, _fragmentWidth) {
+	const blockPmStart = block.pmStart ?? 0;
+	const blockPmEnd = block.pmEnd ?? blockPmStart;
+	if (pmPosition < blockPmStart || pmPosition > blockPmEnd) return null;
+	const positionOffset = pmPosition - blockPmStart;
+	for (let lineIndex = 0; lineIndex < measure.lines.length; lineIndex++) {
+		const line = measure.lines[lineIndex];
+		const { pmStart: linePmStart, pmEnd: linePmEnd } = computeLinePmRange(block, line);
+		if (linePmStart === void 0 || linePmEnd === void 0) continue;
+		const lineStartOffset = linePmStart - blockPmStart;
+		const lineEndOffset = linePmEnd - blockPmStart;
+		if (positionOffset >= lineStartOffset && positionOffset <= lineEndOffset) {
+			const offsetInLine = positionOffset - lineStartOffset;
+			const runs = sliceRunsForLine(block, line);
+			let x = 0;
+			let charsProcessed = 0;
+			for (const run of runs) if (run.kind === "tab") {
+				if (offsetInLine <= charsProcessed + 1) {
+					if (offsetInLine <= charsProcessed) return {
+						x,
+						lineIndex
+					};
+					return {
+						x: x + (run.width ?? 48),
+						lineIndex
+					};
+				}
+				x += run.width ?? 48;
+				charsProcessed += 1;
+			} else if (run.kind === "image") {
+				if (offsetInLine <= charsProcessed + 1) {
+					if (offsetInLine <= charsProcessed) return {
+						x,
+						lineIndex
+					};
+					return {
+						x: x + run.width,
+						lineIndex
+					};
+				}
+				x += run.width;
+				charsProcessed += 1;
+			} else if (run.kind === "lineBreak") {
+				if (offsetInLine <= charsProcessed) return {
+					x,
+					lineIndex
+				};
+				charsProcessed += 1;
+			} else if (run.kind === "text") {
+				const text = run.text;
+				if (offsetInLine <= charsProcessed + text.length) {
+					const charInRun = offsetInLine - charsProcessed;
+					const style = runToFontStyle(run);
+					const measurement = measureRun(text.slice(0, charInRun), style);
+					return {
+						x: x + measurement.width,
+						lineIndex
+					};
+				}
+				const measurement = measureRun(text, runToFontStyle(run));
+				x += measurement.width;
+				charsProcessed += text.length;
+			}
+			return {
+				x,
+				lineIndex
+			};
+		}
+	}
+	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 availableWidth = Math.max(0, fragmentWidth - indentLeft - indentRight);
+	const line = measure.lines[result.lineIndex];
+	if (!line) return null;
+	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(measure.lines, fromLine, result.lineIndex);
+	return {
+		x: fragmentX + indentLeft + alignmentOffset + result.x,
+		y: fragmentY + lineY,
+		height: line.lineHeight
+	};
+}
+//#endregion
+export { clickToPosition, clickToPositionInParagraph, clickToPositionInTableCell, getPositionRect, positionToX, snapPastTrailingSurrogate };