@stll/folio-core 0.1.3 → 0.2.0

package/dist/prosemirror/tableResize.js

@@ -0,0 +1,162 @@
+//#region src/prosemirror/tableResize.ts
+/** 1px ≈ 15 twips at 96dpi (20 twips/pt × 72pt/in ÷ 96px/in). */
+const TWIPS_PER_PIXEL = 15;
+/** Minimum column width (~0.2"). */
+const MIN_CELL_WIDTH_TWIPS = 300;
+/** Minimum row height (~0.14"). */
+const MIN_ROW_HEIGHT_TWIPS = 200;
+/** Walk up from `pmStart + 1` to find the enclosing table node. */
+function findTableAt(view, pmStart) {
+	try {
+		const $pos = view.state.doc.resolve(pmStart + 1);
+		for (let d = $pos.depth; d >= 0; d--) {
+			const node = $pos.node(d);
+			if (node.type.name === "table") return {
+				node,
+				tablePos: $pos.before(d)
+			};
+		}
+	} catch {}
+	return null;
+}
+/** Read the [left, right] column widths at `colIndex` in the table starting at `pmStart`. */
+function readColumnWidths(view, pmStart, colIndex) {
+	const found = findTableAt(view, pmStart);
+	if (!found) return null;
+	const widths = found.node.attrs["columnWidths"];
+	if (!widths) return null;
+	const left = widths[colIndex];
+	const right = widths[colIndex + 1];
+	if (left === void 0 || right === void 0) return null;
+	return {
+		left,
+		right
+	};
+}
+/**
+* Read the row height (in twips) for `rowIndex` in the table starting at
+* `pmStart`. Returns null if the row has no explicit height — the caller
+* can fall back to measuring the rendered DOM cell.
+*/
+function readRowHeight(view, pmStart, rowIndex) {
+	const found = findTableAt(view, pmStart);
+	if (!found) return null;
+	let rowHeight = null;
+	let idx = 0;
+	found.node.forEach((child) => {
+		if (idx === rowIndex) {
+			const h = child.attrs["height"];
+			if (h) rowHeight = h;
+		}
+		idx++;
+	});
+	return rowHeight;
+}
+/** Read the last-column width (the one being resized from the table's right edge). */
+function readColumnWidthAt(view, pmStart, colIndex) {
+	const found = findTableAt(view, pmStart);
+	if (!found) return null;
+	const widths = found.node.attrs["columnWidths"];
+	if (!widths) return null;
+	const width = widths[colIndex];
+	if (width === void 0) return null;
+	return width;
+}
+/**
+* Bake a column-resize into the PM doc: update the table's `columnWidths`
+* attr and every cell at `colIdx` / `colIdx + 1` in every row.
+*/
+function commitColumnResize(view, opts) {
+	const { pmStart, colIdx, newLeft, newRight } = opts;
+	const found = findTableAt(view, pmStart);
+	if (!found) return;
+	const { node, tablePos } = found;
+	const tr = view.state.tr;
+	const widths = [...node.attrs["columnWidths"] ?? []];
+	widths[colIdx] = newLeft;
+	widths[colIdx + 1] = newRight;
+	tr.setNodeMarkup(tablePos, void 0, {
+		...node.attrs,
+		columnWidths: widths,
+		tableLayout: "fixed"
+	});
+	let rowOffset = tablePos + 1;
+	node.forEach((row) => {
+		let cellOffset = rowOffset + 1;
+		let cellColIdx = 0;
+		row.forEach((cell) => {
+			const colspan = cell.attrs["colspan"] || 1;
+			if (cellColIdx === colIdx || cellColIdx === colIdx + 1) {
+				const newWidth = cellColIdx === colIdx ? newLeft : newRight;
+				tr.setNodeMarkup(tr.mapping.map(cellOffset), void 0, {
+					...cell.attrs,
+					width: newWidth,
+					widthType: "dxa",
+					colwidth: null
+				});
+			}
+			cellOffset += cell.nodeSize;
+			cellColIdx += colspan;
+		});
+		rowOffset += row.nodeSize;
+	});
+	view.dispatch(tr);
+}
+/** Bake a row-resize into the PM doc: update the target row's `height` + `heightRule`. */
+function commitRowResize(view, opts) {
+	const { pmStart, rowIdx, newHeight } = opts;
+	const found = findTableAt(view, pmStart);
+	if (!found) return;
+	const { node, tablePos } = found;
+	const tr = view.state.tr;
+	let rowOffset = tablePos + 1;
+	let idx = 0;
+	node.forEach((row) => {
+		if (idx === rowIdx) tr.setNodeMarkup(tr.mapping.map(rowOffset), void 0, {
+			...row.attrs,
+			height: newHeight,
+			heightRule: "atLeast"
+		});
+		rowOffset += row.nodeSize;
+		idx++;
+	});
+	view.dispatch(tr);
+}
+/**
+* Bake a right-edge resize into the PM doc: grow only the last column.
+* Updates `columnWidths[colIdx]` and the cell at `colIdx` in every row.
+*/
+function commitRightEdgeResize(view, opts) {
+	const { pmStart, colIdx, newWidth } = opts;
+	const found = findTableAt(view, pmStart);
+	if (!found) return;
+	const { node, tablePos } = found;
+	const tr = view.state.tr;
+	const widths = [...node.attrs["columnWidths"] ?? []];
+	widths[colIdx] = newWidth;
+	tr.setNodeMarkup(tablePos, void 0, {
+		...node.attrs,
+		columnWidths: widths,
+		tableLayout: "fixed"
+	});
+	let rowOffset = tablePos + 1;
+	node.forEach((row) => {
+		let cellOffset = rowOffset + 1;
+		let cellColIdx = 0;
+		row.forEach((cell) => {
+			const colspan = cell.attrs["colspan"] || 1;
+			if (cellColIdx === colIdx) tr.setNodeMarkup(tr.mapping.map(cellOffset), void 0, {
+				...cell.attrs,
+				width: newWidth,
+				widthType: "dxa",
+				colwidth: null
+			});
+			cellOffset += cell.nodeSize;
+			cellColIdx += colspan;
+		});
+		rowOffset += row.nodeSize;
+	});
+	view.dispatch(tr);
+}
+//#endregion
+export { MIN_CELL_WIDTH_TWIPS, MIN_ROW_HEIGHT_TWIPS, TWIPS_PER_PIXEL, commitColumnResize, commitRightEdgeResize, commitRowResize, readColumnWidthAt, readColumnWidths, readRowHeight };

package/dist/prosemirror/utils/extractTrackedChanges.d.ts

@@ -0,0 +1,106 @@
+import { EditorState } from "prosemirror-state";
+
+//#region src/prosemirror/utils/extractTrackedChanges.d.ts
+/**
+ * One tracked change surfaced by {@link extractTrackedChanges}. Each entry
+ * groups all sites of one revision into a single row that the sidebar
+ * renders as one card.
+ *
+ * @public
+ */
+type TrackedChangeEntry = {
+  /**
+   * Revision shape. Inline shapes (`insertion`, `deletion`, `replacement`)
+   * wrap text runs; the rest are structural revisions on node attrs.
+   *
+   * - `insertion` — text was added (`<w:ins>`).
+   * - `deletion` — text was struck through but not removed (`<w:del>`).
+   * - `replacement` — a deletion + insertion by the same author at the
+   *   same position+time; sidebar shows one combined card. `deletedText`
+   *   and `insertionRevisionId` are set on this variant.
+   * - `paragraphMarkInsertion` / `paragraphMarkDeletion` — Enter /
+   *   Backspace produced a tracked paragraph break (`<w:pPr><w:rPr><w:ins/>` /
+   *   `<w:del/>`).
+   * - `paragraphPropertiesChanged` — formatting (alignment, spacing,
+   *   etc.) on the paragraph was changed (`<w:pPrChange>`).
+   * - `rowInserted` / `rowDeleted` / `rowPropertiesChanged` — table
+   *   row authored / removed / formatted (`<w:trPr><w:ins/>` / `<w:del/>`
+   *   / `<w:trPrChange>`).
+   * - `cellInserted` / `cellDeleted` / `cellMerged` /
+   *   `cellPropertiesChanged` — per-cell revisions
+   *   (`<w:cellIns>` / `<w:cellDel>` / `<w:cellMerge>` / `<w:tcPrChange>`).
+   * - `tablePropertiesChanged` — table-level formatting
+   *   (`<w:tblPrChange>`).
+   */
+  type: "insertion" | "deletion" | "replacement" | "paragraphMarkInsertion" | "paragraphMarkDeletion" | "paragraphPropertiesChanged" | "rowInserted" | "rowDeleted" | "rowPropertiesChanged" | "cellInserted" | "cellDeleted" | "cellMerged" | "cellPropertiesChanged" | "tableInserted" | "tableDeleted" | "tablePropertiesChanged";
+  /**
+   * Affected text. For inline types this is the run's text; for
+   * structural types it's the surrounding paragraph / cell content
+   * (truncated by the sidebar before display).
+   */
+  text: string;
+  /**
+   * Only set when `type === 'replacement'` — the text the user removed.
+   * The inserted text lives in {@link TrackedChangeEntry.text}.
+   */
+  deletedText?: string | undefined; /** Author that minted the revision (`w:author`). */
+  author: string; /** ISO timestamp the revision was minted (`w:date`). May be undefined for legacy imports. */
+  date?: string | undefined;
+  /**
+   * Document position where the revision starts. For inline types this
+   * is the start of the marked text run; for structural types it's the
+   * containing paragraph / row / cell / table node's start position.
+   */
+  from: number;
+  /**
+   * Document position where the revision ends. For inline coalesced
+   * runs that span multiple paragraphs, this is the END position of the
+   * LAST run in the group; the intervening structural positions are not
+   * preserved.
+   */
+  to: number; /** The `w:id` of the revision. */
+  revisionId: number;
+  /**
+   * Only set when `type === 'replacement'` — the insertion half carries
+   * a DIFFERENT `w:id` from the deletion (sharing would trip the OOXML
+   * move-pair serializer).
+   */
+  insertionRevisionId?: number | undefined;
+  /**
+   * Extra `w:id`s that map to the same logical revision as this card.
+   * Populated when the extractor coalesces a burst of distinct ids by
+   * (author, date) — e.g. a foreign document where the source editor
+   * minted a fresh id per atomic edit.
+   */
+  coalescedRevisionIds?: number[] | undefined;
+};
+/**
+ * Output of {@link extractTrackedChanges}.
+ *
+ * @public
+ */
+type TrackedChangesResult = {
+  /** Tracked-change entries, sorted by document position, with adjacent same-revision entries merged. */entries: TrackedChangeEntry[];
+  /**
+   * Map of `commentId -> revisionId` for comments whose range overlaps a tracked-change mark.
+   * Consumers (DocxEditor's threading effect) use this to thread comments under their tracked change.
+   */
+  commentToRevision: Map<number, number>;
+};
+/**
+ * Walk the PM doc and extract every tracked change as a flat list of
+ * `TrackedChangeEntry` plus a comment→revision overlap map. Adjacent
+ * inline marks coalesce by `(type, revisionId, author, date)`; a
+ * deletion immediately followed by an insertion (same author + same
+ * date) collapses into a single `replacement` entry; paragraph-mark
+ * cards (`paragraphMarkInsertion` / `paragraphMarkDeletion`) are
+ * hidden when an inline entry already covers their revision triple
+ * (one Accept clears every site of one conceptual change).
+ *
+ * Pure and deterministic. Returns `EMPTY_RESULT` on null state.
+ *
+ * @public
+ */
+declare function extractTrackedChanges(state: EditorState | null): TrackedChangesResult;
+//#endregion
+export { TrackedChangeEntry, TrackedChangesResult, extractTrackedChanges };

package/dist/prosemirror/utils/extractTrackedChanges.js

@@ -0,0 +1,379 @@
+//#region src/prosemirror/utils/extractTrackedChanges.ts
+const EMPTY_RESULT = {
+	entries: [],
+	commentToRevision: /* @__PURE__ */ new Map()
+};
+/**
+* Walk the PM doc and extract every tracked change as a flat list of
+* `TrackedChangeEntry` plus a comment→revision overlap map. Adjacent
+* inline marks coalesce by `(type, revisionId, author, date)`; a
+* deletion immediately followed by an insertion (same author + same
+* date) collapses into a single `replacement` entry; paragraph-mark
+* cards (`paragraphMarkInsertion` / `paragraphMarkDeletion`) are
+* hidden when an inline entry already covers their revision triple
+* (one Accept clears every site of one conceptual change).
+*
+* Pure and deterministic. Returns `EMPTY_RESULT` on null state.
+*
+* @public
+*/
+function extractTrackedChanges(state) {
+	if (!state) return EMPTY_RESULT;
+	const { doc, schema } = state;
+	const insertionType = schema.marks["insertion"];
+	const deletionType = schema.marks["deletion"];
+	const commentType = schema.marks["comment"];
+	if (!insertionType && !deletionType) return EMPTY_RESULT;
+	const raw = [];
+	const commentToRevision = /* @__PURE__ */ new Map();
+	const commentMetadata = /* @__PURE__ */ new Map();
+	doc.descendants((node, pos) => {
+		if (node.type.name === "paragraph") {
+			const ins = node.attrs["pPrIns"];
+			const del = node.attrs["pPrDel"];
+			if (ins) raw.push({
+				type: "paragraphMarkInsertion",
+				text: node.textContent || "",
+				author: ins.author || "",
+				date: ins.date ?? void 0,
+				from: pos,
+				to: pos + node.nodeSize,
+				revisionId: ins.revisionId
+			});
+			if (del) raw.push({
+				type: "paragraphMarkDeletion",
+				text: node.textContent || "",
+				author: del.author || "",
+				date: del.date ?? void 0,
+				from: pos,
+				to: pos + node.nodeSize,
+				revisionId: del.revisionId
+			});
+			const pPrChange = node.attrs["pPrChange"];
+			if (Array.isArray(pPrChange)) for (const entry of pPrChange) {
+				if (!entry?.info || typeof entry.info.id !== "number") continue;
+				raw.push({
+					type: "paragraphPropertiesChanged",
+					text: node.textContent || "",
+					author: entry.info.author || "",
+					date: entry.info.date ?? void 0,
+					from: pos,
+					to: pos + node.nodeSize,
+					revisionId: entry.info.id
+				});
+			}
+		}
+		if (node.type.name === "tableRow") {
+			const trIns = node.attrs["trIns"];
+			const trDel = node.attrs["trDel"];
+			if (trIns) raw.push({
+				type: "rowInserted",
+				text: node.textContent || "",
+				author: trIns.author || "",
+				date: trIns.date ?? void 0,
+				from: pos,
+				to: pos + node.nodeSize,
+				revisionId: trIns.revisionId
+			});
+			if (trDel) raw.push({
+				type: "rowDeleted",
+				text: node.textContent || "",
+				author: trDel.author || "",
+				date: trDel.date ?? void 0,
+				from: pos,
+				to: pos + node.nodeSize,
+				revisionId: trDel.revisionId
+			});
+			const trPrChange = node.attrs["trPrChange"];
+			if (Array.isArray(trPrChange)) for (const entry of trPrChange) {
+				if (!entry?.info || typeof entry.info.id !== "number") continue;
+				raw.push({
+					type: "rowPropertiesChanged",
+					text: node.textContent || "",
+					author: entry.info.author || "",
+					date: entry.info.date ?? void 0,
+					from: pos,
+					to: pos + node.nodeSize,
+					revisionId: entry.info.id
+				});
+			}
+		}
+		if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+			const cellMarker = node.attrs["cellMarker"];
+			if (cellMarker?.info && typeof cellMarker.info.revisionId === "number") {
+				const resolvedType = {
+					ins: "cellInserted",
+					del: "cellDeleted",
+					merge: "cellMerged"
+				}[cellMarker.kind];
+				if (resolvedType) raw.push({
+					type: resolvedType,
+					text: node.textContent || "",
+					author: cellMarker.info.author || "",
+					date: cellMarker.info.date ?? void 0,
+					from: pos,
+					to: pos + node.nodeSize,
+					revisionId: cellMarker.info.revisionId
+				});
+			}
+			const tcPrChange = node.attrs["tcPrChange"];
+			if (Array.isArray(tcPrChange)) for (const entry of tcPrChange) {
+				if (!entry?.info || typeof entry.info.id !== "number") continue;
+				raw.push({
+					type: "cellPropertiesChanged",
+					text: node.textContent || "",
+					author: entry.info.author || "",
+					date: entry.info.date ?? void 0,
+					from: pos,
+					to: pos + node.nodeSize,
+					revisionId: entry.info.id
+				});
+			}
+		}
+		if (node.type.name === "table") {
+			const tblPrChange = node.attrs["tblPrChange"];
+			if (Array.isArray(tblPrChange)) for (const entry of tblPrChange) {
+				if (!entry?.info || typeof entry.info.id !== "number") continue;
+				raw.push({
+					type: "tablePropertiesChanged",
+					text: "",
+					author: entry.info.author || "",
+					date: entry.info.date ?? void 0,
+					from: pos,
+					to: pos + node.nodeSize,
+					revisionId: entry.info.id
+				});
+			}
+			const firstRow = node.firstChild;
+			const firstIns = firstRow?.attrs["trIns"];
+			const firstDel = firstRow?.attrs["trDel"];
+			let sharedAttr = null;
+			if (firstIns) sharedAttr = "trIns";
+			else if (firstDel) sharedAttr = "trDel";
+			if (sharedAttr) {
+				const sharedRev = firstIns ?? firstDel;
+				let allShare = true;
+				const rowRevIds = [];
+				node.forEach((row) => {
+					if (row.type.name !== "tableRow") {
+						allShare = false;
+						return;
+					}
+					const v = row.attrs[sharedAttr];
+					if (!v || (v.author ?? "") !== (sharedRev.author ?? "") || (v.date ?? null) !== (sharedRev.date ?? null)) {
+						allShare = false;
+						return;
+					}
+					rowRevIds.push(v.revisionId);
+				});
+				if (allShare) {
+					let visibleText = "";
+					if (deletionType) node.descendants((child) => {
+						if (child.isText && !child.marks.some((m) => m.type === deletionType)) visibleText += child.text || "";
+					});
+					else visibleText = node.textContent || "";
+					const primaryId = sharedRev.revisionId;
+					const extraIds = rowRevIds.filter((id, idx) => id !== primaryId && rowRevIds.indexOf(id) === idx);
+					raw.push({
+						type: sharedAttr === "trIns" ? "tableInserted" : "tableDeleted",
+						text: visibleText,
+						author: sharedRev.author || "",
+						date: sharedRev.date ?? void 0,
+						from: pos,
+						to: pos + node.nodeSize,
+						revisionId: primaryId,
+						...extraIds.length > 0 ? { coalescedRevisionIds: extraIds } : {}
+					});
+				}
+			}
+		}
+		if (!node.isInline) return;
+		let inlineText;
+		if (node.isText) inlineText = node.text || "";
+		else if (node.type.name === "image") inlineText = node.attrs["alt"] || "image";
+		else inlineText = node.type.name;
+		let tcMark = null;
+		for (const mark of node.marks) if (mark.type === insertionType || mark.type === deletionType) {
+			raw.push({
+				type: mark.type === insertionType ? "insertion" : "deletion",
+				text: inlineText,
+				author: mark.attrs["author"] || "",
+				date: mark.attrs["date"],
+				from: pos,
+				to: pos + node.nodeSize,
+				revisionId: mark.attrs["revisionId"]
+			});
+			tcMark = mark;
+		}
+		if (commentType) {
+			const commentMark = node.marks.find((m) => m.type === commentType);
+			if (commentMark) {
+				const cid = commentMark.attrs["commentId"];
+				let meta = commentMetadata.get(cid);
+				if (!meta) {
+					meta = {
+						revisions: /* @__PURE__ */ new Set(),
+						hasCleanText: false
+					};
+					commentMetadata.set(cid, meta);
+				}
+				if (tcMark) meta.revisions.add(tcMark.attrs["revisionId"]);
+				else meta.hasCleanText = true;
+			}
+		}
+	});
+	for (const [cid, meta] of commentMetadata.entries()) if (!meta.hasCleanText && meta.revisions.size === 1) {
+		const rid = meta.revisions.values().next().value;
+		commentToRevision.set(cid, rid);
+	}
+	const STRUCTURAL_PRIORITY = {
+		tableInserted: 6,
+		tableDeleted: 6,
+		tablePropertiesChanged: 5,
+		rowInserted: 4,
+		rowDeleted: 4,
+		rowPropertiesChanged: 4,
+		cellInserted: 3,
+		cellDeleted: 3,
+		cellMerged: 3,
+		cellPropertiesChanged: 3,
+		paragraphMarkInsertion: 2,
+		paragraphMarkDeletion: 2,
+		paragraphPropertiesChanged: 2
+	};
+	const isStructuralType = (t) => t in STRUCTURAL_PRIORITY;
+	const slotByKey = /* @__PURE__ */ new Map();
+	const ordered = [];
+	const mergeIds = (survivor, dropped) => {
+		const ids = new Set(survivor.coalescedRevisionIds ?? []);
+		for (const id of dropped.coalescedRevisionIds ?? []) ids.add(id);
+		ids.add(dropped.revisionId);
+		ids.delete(survivor.revisionId);
+		return [...ids];
+	};
+	for (const entry of raw) {
+		if (!isStructuralType(entry.type)) {
+			ordered.push(entry);
+			continue;
+		}
+		const key = `${entry.author}|${entry.date ?? ""}`;
+		const slot = slotByKey.get(key);
+		if (slot === void 0) {
+			slotByKey.set(key, ordered.push(entry) - 1);
+			continue;
+		}
+		const existing = ordered[slot];
+		if ((STRUCTURAL_PRIORITY[entry.type] ?? 0) > (STRUCTURAL_PRIORITY[existing.type] ?? 0)) ordered[slot] = {
+			...entry,
+			coalescedRevisionIds: mergeIds(entry, existing)
+		};
+		else ordered[slot] = {
+			...existing,
+			coalescedRevisionIds: mergeIds(existing, entry)
+		};
+	}
+	const inlineGroups = /* @__PURE__ */ new Map();
+	const merged = [];
+	for (const entry of ordered) {
+		if (!(entry.type === "insertion" || entry.type === "deletion")) {
+			merged.push({ ...entry });
+			continue;
+		}
+		const key = `${entry.type}|${entry.author}|${entry.date ?? ""}`;
+		const group = inlineGroups.get(key);
+		if (group) {
+			const sep = group.to === entry.from ? "" : " ";
+			group.text += sep + entry.text;
+			group.to = entry.to;
+			if (entry.revisionId !== group.revisionId) {
+				const ids = new Set(group.coalescedRevisionIds ?? []);
+				for (const id of entry.coalescedRevisionIds ?? []) ids.add(id);
+				ids.add(entry.revisionId);
+				ids.delete(group.revisionId);
+				group.coalescedRevisionIds = ids.size > 0 ? [...ids] : void 0;
+			}
+		} else {
+			const copy = { ...entry };
+			inlineGroups.set(key, copy);
+			merged.push(copy);
+		}
+	}
+	const final = [];
+	for (let i = 0; i < merged.length; i++) {
+		const curr = merged[i];
+		const next = merged[i + 1];
+		if (curr.type === "deletion" && next && next.type === "insertion" && curr.author === next.author && curr.date === next.date && curr.to === next.from) {
+			final.push({
+				type: "replacement",
+				text: next.text,
+				deletedText: curr.text,
+				author: curr.author,
+				date: curr.date,
+				from: curr.from,
+				to: next.to,
+				revisionId: curr.revisionId,
+				insertionRevisionId: next.revisionId
+			});
+			i++;
+		} else final.push(curr);
+	}
+	const inlineByKey = /* @__PURE__ */ new Map();
+	for (const e of final) if (e.type === "insertion" || e.type === "deletion" || e.type === "replacement") {
+		const k = `${e.author}|${e.date ?? ""}`;
+		if (!inlineByKey.has(k)) inlineByKey.set(k, e);
+	}
+	for (const e of final) {
+		if (e.type !== "paragraphMarkInsertion" && e.type !== "paragraphMarkDeletion") continue;
+		const survivor = inlineByKey.get(`${e.author}|${e.date ?? ""}`);
+		if (!survivor) continue;
+		const ids = new Set(survivor.coalescedRevisionIds ?? []);
+		for (const id of e.coalescedRevisionIds ?? []) ids.add(id);
+		ids.add(e.revisionId);
+		ids.delete(survivor.revisionId);
+		if (survivor.type === "replacement" && survivor.insertionRevisionId != null) ids.delete(survivor.insertionRevisionId);
+		survivor.coalescedRevisionIds = ids.size > 0 ? [...ids] : void 0;
+	}
+	const emptyTableEntries = /* @__PURE__ */ new Set();
+	const tableByKey = /* @__PURE__ */ new Map();
+	for (const e of final) {
+		if (e.type !== "tableInserted" && e.type !== "tableDeleted") continue;
+		const key = `${e.author}|${e.date ?? ""}`;
+		if (e.text.trim().length > 0) continue;
+		emptyTableEntries.add(e);
+		if (!tableByKey.has(key)) tableByKey.set(key, e);
+	}
+	for (const e of final) {
+		if (e.type !== "paragraphMarkInsertion" && e.type !== "paragraphMarkDeletion") continue;
+		const survivor = tableByKey.get(`${e.author}|${e.date ?? ""}`);
+		if (!survivor) continue;
+		const ids = new Set(survivor.coalescedRevisionIds ?? []);
+		for (const id of e.coalescedRevisionIds ?? []) ids.add(id);
+		ids.add(e.revisionId);
+		ids.delete(survivor.revisionId);
+		survivor.coalescedRevisionIds = ids.size > 0 ? [...ids] : void 0;
+	}
+	const inlineHosts = final.filter((e) => e.type === "insertion" || e.type === "replacement");
+	const foldedPropChanges = /* @__PURE__ */ new Set();
+	for (const e of final) {
+		if (e.type !== "paragraphPropertiesChanged") continue;
+		const host = inlineHosts.find((c) => c.author === e.author && c.from < e.to && e.from < c.to);
+		if (!host) continue;
+		const ids = new Set(mergeIds(host, e));
+		if (host.type === "replacement" && host.insertionRevisionId != null) ids.delete(host.insertionRevisionId);
+		host.coalescedRevisionIds = ids.size > 0 ? [...ids] : void 0;
+		foldedPropChanges.add(e);
+	}
+	return {
+		entries: final.filter((e) => {
+			const key = `${e.author}|${e.date ?? ""}`;
+			if (e.type === "tableInserted" || e.type === "tableDeleted") return emptyTableEntries.has(e);
+			if (e.type === "paragraphMarkInsertion" || e.type === "paragraphMarkDeletion") return !inlineByKey.has(key) && !tableByKey.has(key);
+			if (e.type === "paragraphPropertiesChanged") return !foldedPropChanges.has(e);
+			if (e.type === "insertion" || e.type === "deletion" || e.type === "replacement") return !tableByKey.has(key);
+			return true;
+		}),
+		commentToRevision
+	};
+}
+//#endregion
+export { extractTrackedChanges };

package/dist/prosemirror/utils/visualLineNavigation.d.ts

@@ -0,0 +1,27 @@
+import { EditorView } from "prosemirror-view";
+
+//#region src/prosemirror/utils/visualLineNavigation.d.ts
+/** @internal */
+type VisualLineState = {
+  stickyX: number | null;
+  lastVisualLineIndex: number;
+};
+/** @internal */
+declare function createVisualLineState(): VisualLineState;
+/** @internal */
+declare function getCaretClientX(container: HTMLElement, pmPos: number): number | null;
+/** @internal */
+declare function findLineElementAtPosition(container: HTMLElement, pmPos: number): HTMLElement | null;
+/** @internal */
+declare function findPositionOnLineAtClientX(lineEl: HTMLElement, clientX: number): number | null;
+/**
+ * Handle PM ArrowUp / ArrowDown with visual-line awareness + sticky
+ * X. Returns true if the event was handled and PM should not run
+ * its default behaviour. Mutates `state` so consecutive presses
+ * keep the same sticky X.
+ *
+ * @internal
+ */
+declare function handleVisualLineKeyDown(state: VisualLineState, view: EditorView, event: KeyboardEvent, container: HTMLElement | null): boolean;
+//#endregion
+export { VisualLineState, createVisualLineState, findLineElementAtPosition, findPositionOnLineAtClientX, getCaretClientX, handleVisualLineKeyDown };