@stll/folio-core 0.52.0 → 0.54.0

package/dist/prosemirror/tableGridMutation.d.ts

@@ -1,6 +1,54 @@
-import { Transaction } from "prosemirror-state";
 import { Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
+import { TableMap } from "prosemirror-tables";
 //#region src/prosemirror/tableGridMutation.d.ts
+type RemoveTableRowOptions = {
+  map: TableMap;
+  table: Node;
+  tableStart: number;
+};
+/**
+ * Remove one row, keeping every vertical merge that touches it whole: a merge
+ * reaching through the row from above closes one row sooner, and a cell that
+ * starts in the row and spans down moves into the row below, one row shorter.
+ *
+ * `prosemirror-tables` exports the same operation as `removeRow`, but its walk
+ * across the row skips a cell's extra columns without moving its map index
+ * along with them, so after a cell wider than one column it reads the wrong
+ * slots: a merge reaching through the row further right is never shortened,
+ * and the table is left one row shorter than that merge.
+ */
+declare const removeTableRow: (tr: Transaction, { map, table, tableStart }: RemoveTableRowOptions, row: number) => void;
+/** Whether a batch of structural deletions may have emptied rows. */
+type RowsEmptiedInBatch = {
+  pending: boolean;
+};
+type MarkRowEmptiedInBatchOptions = {
+  tr: Transaction;
+  rowPosition: number;
+  emptied: RowsEmptiedInBatch;
+};
+/** A transient row attribute follows node moves; conversion never serializes it. */
+declare const markRowEmptiedInBatch: ({ tr, rowPosition, emptied }: MarkRowEmptiedInBatchOptions) => void;
+type MarkRowsEmptiedInBatchOptions = {
+  tr: Transaction;
+  tablePosition: number;
+  previousTable: Node;
+  emptied: RowsEmptiedInBatch;
+};
+/** Column removal keeps row indices stable: mark only newly cell-less rows. */
+declare const markRowsEmptiedInBatch: ({ tr, tablePosition, previousTable, emptied }: MarkRowsEmptiedInBatchOptions) => void;
+/** Sweep current tables in reverse so moves cannot invalidate cleanup targets. */
+declare const removeRowsWithoutCellsAfterBatch: (tr: Transaction, emptied: RowsEmptiedInBatch) => void;
+type RemoveRowsWithoutCellsInRangeOptions = {
+  tr: Transaction;
+  from: number;
+  to: number;
+};
+/** Close marked rows before their owning cell is captured into a continuation payload. */
+declare const removeRowsWithoutCellsInRange: ({ tr, from, to }: RemoveRowsWithoutCellsInRangeOptions) => void;
+/** Close all cell-less rows after an immediate structural edit. */
+declare const removeRowsWithoutCells: (tr: Transaction, tablePosition: number) => void;
 type ReconcileTableGridAfterColumnRemovalOptions = {
   tr: Transaction;
   tablePosition: number;
@@ -16,5 +64,42 @@ type ReconcileTableGridAfterColumnRemovalOptions = {
  * the old grid; reopening then has to interpret surviving cells as spans.
  */
 declare const reconcileTableGridAfterColumnRemoval: ({ tr, tablePosition, previousTable, removedColumn }: ReconcileTableGridAfterColumnRemovalOptions) => void;
+type ReconcileTableGridAfterColumnInsertionOptions = {
+  tr: Transaction;
+  tablePosition: number;
+  previousTable: Node;
+  insertedColumn: number;
+};
+/**
+ * The same for a physical column insertion: the new grid column takes the
+ * width of the column beside it, and the table grows by it.
+ *
+ * Without it the table keeps the grid it had, so every row spans one column
+ * more than `w:tblGrid` declares.
+ */
+declare const reconcileTableGridAfterColumnInsertion: ({ tr, tablePosition, previousTable, insertedColumn }: ReconcileTableGridAfterColumnInsertionOptions) => void;
+type InsertTableColumnOptions = {
+  tr: Transaction;
+  tablePosition: number;
+  /** The grid column the new column takes; the columns from it on move right. */
+  column: number;
+  /** The grid column whose cells the new cells copy their formatting from. */
+  templateColumn: number;
+  /** A new, empty cell shaped after `template`, the row's cell in the template column. */
+  createCell: (template: Node | null) => Node;
+};
+/**
+ * Insert a grid column, walking the table map: each row gains a cell at the
+ * column's place in the grid (after any cell a merge from a row above holds
+ * there), a cell merged across that place widens instead, and `w:tblGrid`
+ * gains the column.
+ */
+declare const insertTableColumn: ({ tr, tablePosition, column, templateColumn, createCell }: InsertTableColumnOptions) => void;
+/**
+ * Remove grid columns [`left`, `right`), walking the table map: a cell only
+ * in them goes, a cell merged across them narrows, `w:tblGrid` loses them,
+ * and a row left without a cell of its own goes too.
+ */
+declare const removeTableColumns: (tr: Transaction, tablePosition: number, left: number, right: number) => void;
 //#endregion
-export { reconcileTableGridAfterColumnRemoval };
+export { RowsEmptiedInBatch, insertTableColumn, markRowEmptiedInBatch, markRowsEmptiedInBatch, reconcileTableGridAfterColumnInsertion, reconcileTableGridAfterColumnRemoval, removeRowsWithoutCells, removeRowsWithoutCellsAfterBatch, removeRowsWithoutCellsInRange, removeTableColumns, removeTableRow };

package/dist/prosemirror/tableGridMutation.js

@@ -1,7 +1,124 @@
 import { expectTableAttrs, mergeTableAttrs } from "./attrs/index.js";
-import { TableMap } from "prosemirror-tables";
+import { panic } from "better-result";
+import { TableMap, removeColumn } from "prosemirror-tables";
 //#region src/prosemirror/tableGridMutation.ts
 /**
+* Remove one row, keeping every vertical merge that touches it whole: a merge
+* reaching through the row from above closes one row sooner, and a cell that
+* starts in the row and spans down moves into the row below, one row shorter.
+*
+* `prosemirror-tables` exports the same operation as `removeRow`, but its walk
+* across the row skips a cell's extra columns without moving its map index
+* along with them, so after a cell wider than one column it reads the wrong
+* slots: a merge reaching through the row further right is never shortened,
+* and the table is left one row shorter than that merge.
+*/
+const removeTableRow = (tr, { map, table, tableStart }, row) => {
+	let rowPosition = 0;
+	for (let index = 0; index < row; index++) rowPosition += table.child(index).nodeSize;
+	const nextRow = rowPosition + table.child(row).nodeSize;
+	const mapFrom = tr.mapping.maps.length;
+	tr.delete(tableStart + rowPosition, tableStart + nextRow);
+	for (let column = 0; column < map.width;) {
+		const index = row * map.width + column;
+		const position = map.map[index];
+		const cell = position === void 0 ? null : table.nodeAt(position);
+		if (position === void 0 || !cell) {
+			column += 1;
+			continue;
+		}
+		const colspan = Math.max(1, Number(cell.attrs["colspan"]) || 1);
+		const rowspan = Math.max(1, Number(cell.attrs["rowspan"]) || 1);
+		if (row > 0 && position === map.map[index - map.width]) tr.setNodeMarkup(tr.mapping.slice(mapFrom).map(tableStart + position), null, {
+			...cell.attrs,
+			rowspan: rowspan - 1
+		});
+		else if (row + 1 < map.height && position === map.map[index + map.width]) {
+			const moved = cell.type.create({
+				...cell.attrs,
+				rowspan: rowspan - 1
+			}, cell.content);
+			const below = map.positionAt(row + 1, column, table);
+			tr.insert(tr.mapping.slice(mapFrom).map(tableStart + below), moved);
+		}
+		column += colspan;
+	}
+};
+const ROW_CLEANUP_PENDING = "pending";
+/** A transient row attribute follows node moves; conversion never serializes it. */
+const markRowEmptiedInBatch = ({ tr, rowPosition, emptied }) => {
+	const row = tr.doc.nodeAt(rowPosition);
+	if (!row || row.type.spec.attrs?.["_batchRowCleanup"] === void 0) panic("Batch row cleanup requires the table row cleanup attribute");
+	tr.setNodeAttribute(rowPosition, "_batchRowCleanup", ROW_CLEANUP_PENDING);
+	emptied.pending = true;
+};
+/** Column removal keeps row indices stable: mark only newly cell-less rows. */
+const markRowsEmptiedInBatch = ({ tr, tablePosition, previousTable, emptied }) => {
+	const table = tr.doc.nodeAt(tablePosition);
+	if (!table || table.type.spec["tableRole"] !== "table") return;
+	table.forEach((row, offset, index) => {
+		if (row.childCount === 0 && previousTable.child(index).childCount > 0) markRowEmptiedInBatch({
+			tr,
+			rowPosition: tablePosition + 1 + offset,
+			emptied
+		});
+	});
+};
+const removeEmptyRows = ({ tr, tablePosition, shouldRemove }) => {
+	for (;;) {
+		const table = tr.doc.nodeAt(tablePosition);
+		if (!table || table.type.spec["tableRole"] !== "table" || table.childCount < 2) return;
+		let emptyRow = -1;
+		table.forEach((row, _offset, index) => {
+			if (emptyRow === -1 && row.childCount === 0 && shouldRemove(row)) emptyRow = index;
+		});
+		if (emptyRow === -1) return;
+		removeTableRow(tr, {
+			map: TableMap.get(table),
+			table,
+			tableStart: tablePosition + 1
+		}, emptyRow);
+	}
+};
+/** Remove only rows emptied by deletions in this transaction, then clear remaining markers. */
+const removeBatchRows = (tr, tablePosition) => {
+	removeEmptyRows({
+		tr,
+		tablePosition,
+		shouldRemove: (row) => row.attrs["_batchRowCleanup"] === ROW_CLEANUP_PENDING
+	});
+	tr.doc.nodeAt(tablePosition)?.forEach((row, offset) => {
+		if (row.attrs["_batchRowCleanup"] === ROW_CLEANUP_PENDING) tr.setNodeAttribute(tablePosition + 1 + offset, "_batchRowCleanup", null);
+	});
+};
+/** Sweep current tables in reverse so moves cannot invalidate cleanup targets. */
+const removeRowsWithoutCellsAfterBatch = (tr, emptied) => {
+	if (!emptied.pending) return;
+	const tables = [];
+	tr.doc.descendants((node, position) => {
+		if (node.type.spec["tableRole"] === "table") tables.push(position);
+		return !node.isTextblock;
+	});
+	for (const position of tables.toReversed()) removeBatchRows(tr, position);
+};
+/** Close marked rows before their owning cell is captured into a continuation payload. */
+const removeRowsWithoutCellsInRange = ({ tr, from, to }) => {
+	const tables = [];
+	tr.doc.nodesBetween(from, to, (node, position) => {
+		if (position >= from && node.type.spec["tableRole"] === "table") tables.push(position);
+		return !node.isTextblock;
+	});
+	for (const position of tables.toReversed()) removeBatchRows(tr, position);
+};
+/** Close all cell-less rows after an immediate structural edit. */
+const removeRowsWithoutCells = (tr, tablePosition) => {
+	removeEmptyRows({
+		tr,
+		tablePosition,
+		shouldRemove: () => true
+	});
+};
+/**
 * Keep the editable table grid aligned with a physical column removal.
 *
 * `prosemirror-tables` owns cell topology, but Folio separately retains the
@@ -18,6 +135,63 @@ const reconcileTableGridAfterColumnRemoval = ({ tr, tablePosition, previousTable
 	const removedColumnCount = previousColumnCount - columnCount;
 	const previousWidths = expectTableAttrs(previousTable).columnWidths;
 	const columnWidths = previousWidths?.length === previousColumnCount ? previousWidths.toSpliced(removedColumn, removedColumnCount) : void 0;
+	setTableGrid({
+		tr,
+		tablePosition,
+		table,
+		columnWidths,
+		columnCount
+	});
+};
+/**
+* The same for a physical column insertion: the new grid column takes the
+* width of the column beside it, and the table grows by it.
+*
+* Without it the table keeps the grid it had, so every row spans one column
+* more than `w:tblGrid` declares.
+*/
+const reconcileTableGridAfterColumnInsertion = ({ tr, tablePosition, previousTable, insertedColumn }) => {
+	const previousColumnCount = TableMap.get(previousTable).width;
+	const table = tr.doc.nodeAt(tablePosition);
+	if (!table || table.type.spec["tableRole"] !== "table") return;
+	const columnCount = TableMap.get(table).width;
+	if (columnCount <= previousColumnCount) return;
+	const insertedColumnCount = columnCount - previousColumnCount;
+	const previousWidths = expectTableAttrs(previousTable).columnWidths;
+	const neighbourWidth = insertedColumnWidth(previousTable, insertedColumn);
+	const columnWidths = previousWidths?.length === previousColumnCount && neighbourWidth !== void 0 ? previousWidths.toSpliced(insertedColumn, 0, ...Array.from({ length: insertedColumnCount }, () => neighbourWidth)) : void 0;
+	setTableGrid({
+		tr,
+		tablePosition,
+		table,
+		columnWidths,
+		columnCount
+	});
+};
+/** The width a column inserted at `insertedColumn` takes: its left neighbour's, when the grid is known. */
+const insertedColumnWidth = (table, insertedColumn) => {
+	const columnCount = TableMap.get(table).width;
+	const widths = expectTableAttrs(table).columnWidths;
+	if (widths?.length !== columnCount) return;
+	return widths[Math.max(0, Math.min(insertedColumn, columnCount) - 1)] ?? widths[0];
+};
+/**
+* Give a cell whose span grew or shrank the matching rendered width: its
+* resolved twips width moves by `delta`. Layout falls back to cell widths
+* when the grid is unknown, so a merged cell must not keep its old one. A
+* percentage width, and the authored `w:tcW` kept beside it, stay as they are.
+*/
+const resizeCellWidth = (tr, position, delta) => {
+	const cell = tr.doc.nodeAt(position);
+	const width = cell?.attrs["width"];
+	const widthType = cell?.attrs["widthType"];
+	if (!cell || delta === 0 || typeof width !== "number" || widthType !== null && widthType !== void 0 && widthType !== "dxa") return;
+	tr.setNodeMarkup(position, null, {
+		...cell.attrs,
+		width: Math.max(1, width + delta)
+	});
+};
+const setTableGrid = ({ tr, tablePosition, table, columnWidths, columnCount }) => {
 	const formatting = expectTableAttrs(table)._originalFormatting;
 	const originalFormatting = formatting ? { ...formatting } : void 0;
 	if (originalFormatting) delete originalFormatting.gridSourceXml;
@@ -26,5 +200,84 @@ const reconcileTableGridAfterColumnRemoval = ({ tr, tablePosition, previousTable
 		_originalFormatting: originalFormatting
 	}));
 };
+/**
+* Insert a grid column, walking the table map: each row gains a cell at the
+* column's place in the grid (after any cell a merge from a row above holds
+* there), a cell merged across that place widens instead, and `w:tblGrid`
+* gains the column.
+*/
+const insertTableColumn = ({ tr, tablePosition, column, templateColumn, createCell }) => {
+	const table = tr.doc.nodeAt(tablePosition);
+	if (!table || table.type.spec["tableRole"] !== "table") return;
+	const map = TableMap.get(table);
+	const tableStart = tablePosition + 1;
+	const mapFrom = tr.mapping.maps.length;
+	const addedWidth = insertedColumnWidth(table, column) ?? 0;
+	for (let row = 0; row < map.height; row++) {
+		const index = row * map.width + column;
+		const position = map.map[index];
+		const straddling = column > 0 && column < map.width && position !== void 0 && map.map[index - 1] === position ? table.nodeAt(position) : null;
+		if (straddling && position !== void 0) {
+			const offset = column - map.colCount(position);
+			const colwidth = straddling.attrs["colwidth"];
+			const mapped = tr.mapping.slice(mapFrom).map(tableStart + position);
+			tr.setNodeMarkup(mapped, null, {
+				...straddling.attrs,
+				colspan: (Number(straddling.attrs["colspan"]) || 1) + 1,
+				colwidth: Array.isArray(colwidth) ? colwidth.toSpliced(offset, 0, 0) : colwidth
+			});
+			resizeCellWidth(tr, mapped, addedWidth);
+			row += (Number(straddling.attrs["rowspan"]) || 1) - 1;
+			continue;
+		}
+		const templatePosition = map.map[row * map.width + templateColumn];
+		const template = templatePosition === void 0 ? null : table.nodeAt(templatePosition);
+		tr.insert(tr.mapping.slice(mapFrom).map(tableStart + map.positionAt(row, column, table)), createCell(template));
+	}
+	reconcileTableGridAfterColumnInsertion({
+		tr,
+		tablePosition,
+		previousTable: table,
+		insertedColumn: column
+	});
+};
+/**
+* Remove grid columns [`left`, `right`), walking the table map: a cell only
+* in them goes, a cell merged across them narrows, `w:tblGrid` loses them,
+* and a row left without a cell of its own goes too.
+*/
+const removeTableColumns = (tr, tablePosition, left, right) => {
+	for (let column = right - 1; column >= left; column--) {
+		const table = tr.doc.nodeAt(tablePosition);
+		if (!table || table.type.spec["tableRole"] !== "table") return;
+		const map = TableMap.get(table);
+		const widths = expectTableAttrs(table).columnWidths;
+		const removedWidth = widths?.length === map.width ? widths[column] ?? 0 : 0;
+		const narrowed = /* @__PURE__ */ new Set();
+		for (let row = 0; row < map.height; row++) {
+			const index = row * map.width + column;
+			const position = map.map[index];
+			if (position !== void 0 && (column > 0 && map.map[index - 1] === position || column < map.width - 1 && map.map[index + 1] === position)) narrowed.add(position);
+		}
+		const mapFrom = tr.mapping.maps.length;
+		removeColumn(tr, {
+			map,
+			table,
+			tableStart: tablePosition + 1,
+			left: column,
+			right: column + 1,
+			top: 0,
+			bottom: map.height
+		}, column);
+		for (const position of narrowed) resizeCellWidth(tr, tr.mapping.slice(mapFrom).map(tablePosition + 1 + position), -removedWidth);
+		reconcileTableGridAfterColumnRemoval({
+			tr,
+			tablePosition,
+			previousTable: table,
+			removedColumn: column
+		});
+	}
+	removeRowsWithoutCells(tr, tablePosition);
+};
 //#endregion
-export { reconcileTableGridAfterColumnRemoval };
+export { insertTableColumn, markRowEmptiedInBatch, markRowsEmptiedInBatch, reconcileTableGridAfterColumnInsertion, reconcileTableGridAfterColumnRemoval, removeRowsWithoutCells, removeRowsWithoutCellsAfterBatch, removeRowsWithoutCellsInRange, removeTableColumns, removeTableRow };

package/dist/prosemirror/tableRunIn.d.ts

@@ -0,0 +1,51 @@
+import { RunStyleResolver } from "./runStyleFormatting.js";
+import { ParagraphPropertySourceTransfer } from "../docx/paragraphPropertySource.js";
+import { MarkType, Node } from "prosemirror-model";
+import { StepMap, Transform } from "prosemirror-transform";
+//#region src/prosemirror/tableRunIn.d.ts
+/**
+ * Whether the cell a paragraph's words would run into is itself pending: its
+ * row or the cell (through nested tables' first cells) is inserted, deleted
+ * or merged, so resolving may not keep it. Pending rows or cells elsewhere in
+ * the table leave that cell where it is.
+ */
+declare const runInCellPending: (table: Node) => boolean;
+type RunParagraphIntoTableOptions = {
+  tr: Transform;
+  paragraphPos: number;
+  styleResolver: RunStyleResolver | null;
+  /** Content a resolution in progress removes: it does not count as words left. */
+  removedMark?: MarkType | undefined;
+};
+/**
+ * Run the paragraph at `paragraphPos` on into the table right after it.
+ * Returns where the paragraph that took its words now starts and the
+ * paragraph-property source it hands over, or null when it did not run in and
+ * the caller keeps its own handling.
+ */
+declare const runParagraphIntoTable: ({ tr, paragraphPos, styleResolver, removedMark }: RunParagraphIntoTableOptions) => {
+  position: number;
+  map: StepMap;
+  transfer: ParagraphPropertySourceTransfer;
+} | null;
+/**
+ * Whether resolving every change in `mode` runs `paragraph` on into `next`:
+ * its mark goes and `next` is a table.
+ */
+declare const runsIntoFollowingTable: (paragraph: Node, next: Node | null | undefined, mode: "accept" | "reject") => boolean;
+/**
+ * Before every change in a story is resolved: run each paragraph whose mark
+ * goes and that sits right before a table on into that table. Returns each
+ * paragraph that took words (its position after the step count given) and
+ * the paragraph-property sources handed over.
+ */
+declare const runParagraphsIntoTables: (tr: Transform, mode: "accept" | "reject", styleResolver: RunStyleResolver | null) => {
+  targets: {
+    position: number;
+    step: number;
+  }[];
+  maps: StepMap[];
+  transfers: ParagraphPropertySourceTransfer[];
+};
+//#endregion
+export { runInCellPending, runParagraphIntoTable, runParagraphsIntoTables, runsIntoFollowingTable };

package/dist/prosemirror/tableRunIn.js

@@ -0,0 +1,165 @@
+import { getProseParagraphPropertySourceToken, recreateProseNodeWithParagraphPropertySource } from "../docx/paragraphPropertySource.js";
+import { expectParagraphAttrs } from "./attrs/index.js";
+import { rebaseParagraphRuns } from "./rebaseParagraphRunFormatting.js";
+import { paragraphRunStyleContext } from "./runStyleFormatting.js";
+import { holdsNoContent } from "./zeroWidthAnchors.js";
+import { Fragment, Slice } from "prosemirror-model";
+import { ReplaceAroundStep, StepMap } from "prosemirror-transform";
+//#region src/prosemirror/tableRunIn.ts
+/**
+* A paragraph whose mark goes, right before a table.
+*
+* With its mark gone a paragraph runs on into what follows it. When that is a
+* table, its words run on into the table's first cell: they lead that cell's
+* first paragraph, which is the paragraph left, with its identity and
+* properties. What the removed paragraph's style lent its runs is re-read in
+* that paragraph's style, as in any join.
+*
+* A paragraph with nothing left to carry is simply removed by the resolvers;
+* one that ends a section keeps its place, as does one before a table whose
+* rows or cells are themselves pending.
+*/
+/**
+* Whether the cell a paragraph's words would run into is itself pending: its
+* row or the cell (through nested tables' first cells) is inserted, deleted
+* or merged, so resolving may not keep it. Pending rows or cells elsewhere in
+* the table leave that cell where it is.
+*/
+const runInCellPending = (table) => {
+	let node = table;
+	while (node?.type.spec["tableRole"] === "table") {
+		const row = node.firstChild;
+		if (!row) return false;
+		if (row.attrs["trIns"] != null || row.attrs["trDel"] != null) return true;
+		const cell = row.firstChild;
+		if (!cell) return false;
+		if (cell.attrs["cellMarker"] != null) return true;
+		node = cell.firstChild;
+	}
+	return false;
+};
+/** The first paragraph of a table's first cell, descending into nested tables. */
+const runInTarget = (doc, tablePos) => {
+	let node = doc.nodeAt(tablePos);
+	let pos = tablePos;
+	const table = node;
+	const firstRow = table?.firstChild;
+	if (!table || table.type.spec["tableRole"] !== "table" || !firstRow) return null;
+	if (runInCellPending(table)) return null;
+	while (node && node.type.name !== "paragraph") {
+		const child = node.firstChild;
+		if (!child || child.isInline) return null;
+		pos += 1;
+		node = child;
+	}
+	return node ? {
+		pos,
+		node
+	} : null;
+};
+/**
+* Run the paragraph at `paragraphPos` on into the table right after it.
+* Returns where the paragraph that took its words now starts and the
+* paragraph-property source it hands over, or null when it did not run in and
+* the caller keeps its own handling.
+*/
+const runParagraphIntoTable = ({ tr, paragraphPos, styleResolver, removedMark }) => {
+	const paragraph = tr.doc.nodeAt(paragraphPos);
+	if (paragraph?.type.name !== "paragraph") return null;
+	if (expectParagraphAttrs(paragraph)._sectionProperties !== void 0) return null;
+	if (holdsNoContent(removedMark ? paragraph.copy(Fragment.fromArray(paragraph.children.filter((child) => !removedMark.isInSet(child.marks)))) : paragraph)) return null;
+	const tablePos = paragraphPos + paragraph.nodeSize;
+	const target = runInTarget(tr.doc, tablePos);
+	if (!target) return null;
+	const $target = tr.doc.resolve(target.pos + 1);
+	const containerDepth = tr.doc.resolve(paragraphPos).depth;
+	let opening = Fragment.empty;
+	for (let depth = $target.depth; depth > containerDepth; depth--) opening = Fragment.from(recreateProseNodeWithParagraphPropertySource($target.node(depth), { content: opening }));
+	const levels = $target.depth - containerDepth;
+	tr.step(new ReplaceAroundStep(paragraphPos, target.pos + 1, paragraphPos + 1, paragraphPos + paragraph.nodeSize - 1, new Slice(opening, 0, levels), levels, true));
+	const position = paragraphPos + levels - 1;
+	if (styleResolver && paragraph.content.size > 0) rebaseParagraphRuns({
+		previousContext: paragraphRunStyleContext(paragraph, styleResolver),
+		paragraphPosition: position,
+		range: {
+			from: 0,
+			to: paragraph.content.size
+		},
+		styleResolver,
+		tr
+	});
+	const displaced = getProseParagraphPropertySourceToken(paragraph);
+	const selected = getProseParagraphPropertySourceToken(target.node);
+	const closing = paragraphPos + paragraph.nodeSize - 1;
+	return {
+		position,
+		map: new StepMap([
+			paragraphPos,
+			0,
+			levels - 1,
+			closing,
+			target.pos + 1 - closing,
+			0
+		]),
+		transfer: {
+			displacedToken: typeof displaced === "string" ? displaced : null,
+			selectedToken: typeof selected === "string" ? selected : null
+		}
+	};
+};
+/** Whether resolving every change in `mode` removes this paragraph's mark. */
+const markGoes = (paragraph, mode) => {
+	const mark = expectParagraphAttrs(paragraph).pPrMark;
+	if (!mark) return false;
+	return (mark.kind === "ins" || mark.kind === "moveTo") !== (mode === "accept");
+};
+/**
+* Whether resolving every change in `mode` runs `paragraph` on into `next`:
+* its mark goes and `next` is a table.
+*/
+const runsIntoFollowingTable = (paragraph, next, mode) => paragraph.type.name === "paragraph" && next?.type.spec["tableRole"] === "table" && markGoes(paragraph, mode);
+/**
+* Before every change in a story is resolved: run each paragraph whose mark
+* goes and that sits right before a table on into that table. Returns each
+* paragraph that took words (its position after the step count given) and
+* the paragraph-property sources handed over.
+*/
+const runParagraphsIntoTables = (tr, mode, styleResolver) => {
+	const removedMark = tr.doc.type.schema.marks[mode === "accept" ? "deletion" : "insertion"];
+	const tried = /* @__PURE__ */ new Set();
+	const targets = [];
+	const transfers = [];
+	const maps = [];
+	for (;;) {
+		let candidate = null;
+		tr.doc.descendants((node, pos, parent, index) => {
+			if (node.type.name !== "paragraph") return !node.isTextblock;
+			const next = parent?.maybeChild(index + 1);
+			if (runsIntoFollowingTable(node, next, mode) && !tried.has(pos)) candidate = pos;
+			return false;
+		});
+		if (candidate === null) return {
+			targets,
+			maps,
+			transfers
+		};
+		tried.add(candidate);
+		const ranIn = runParagraphIntoTable({
+			tr,
+			paragraphPos: candidate,
+			styleResolver,
+			removedMark
+		});
+		if (ranIn !== null) {
+			targets.push({
+				position: ranIn.position,
+				step: tr.steps.length
+			});
+			transfers.push(ranIn.transfer);
+			maps.push(ranIn.map);
+			tried.clear();
+		}
+	}
+};
+//#endregion
+export { runInCellPending, runParagraphIntoTable, runParagraphsIntoTables, runsIntoFollowingTable };

package/dist/prosemirror/textInput.js

@@ -1,9 +1,18 @@
-import { Plugin } from "prosemirror-state";
+import { AllSelection, Plugin, Selection, TextSelection } from "prosemirror-state";
 //#region src/prosemirror/textInput.ts
 const dispatchEditorTextInput = (view, input) => {
 	const { from, to } = typeof input === "string" ? view.state.selection : input;
 	const text = typeof input === "string" ? input : input.text;
-	const defaultTransaction = () => view.state.tr.insertText(text, from, to);
+	const defaultTransaction = () => {
+		if (!(view.state.selection instanceof AllSelection)) return view.state.tr.insertText(text, from, to);
+		const start = Selection.atStart(view.state.doc);
+		const end = Selection.atEnd(view.state.doc);
+		const last = end.$to.parent;
+		const tr = view.state.tr.insertText(text, start.from, end.to);
+		const $typed = tr.doc.resolve(start.from);
+		if (start.$from.parent.type.name === "paragraph" && last.type.name === "paragraph" && $typed.parent.type.name === "paragraph" && start.$from.parent !== last) tr.setNodeMarkup($typed.before(), void 0, last.attrs);
+		return tr.setSelection(TextSelection.create(tr.doc, start.from + text.length));
+	};
 	if (!view.someProp("handleTextInput", (handler) => handler(view, from, to, text, defaultTransaction))) view.dispatch(defaultTransaction());
 };
 const replacementSelection = (view, event) => {

package/dist/prosemirror/trackedRevisionPath.d.ts

@@ -0,0 +1,17 @@
+import { InlineWrapperLayer, TrackedRevisionAncestor } from "./schema/marks.js";
+import { Mark, Node } from "prosemirror-model";
+//#region src/prosemirror/trackedRevisionPath.d.ts
+/** The wrappers `node` sits inside, outermost first; empty when it sits in none. */
+declare const inlineWrapperStackOf: (node: Node) => readonly InlineWrapperLayer[];
+/** One layer of the path used to write and enumerate a tracked run. */
+declare const trackedRevisionLayerOf: (mark: Mark, node: Node) => TrackedRevisionAncestor;
+type EnclosingInsertionAncestorsOptions = {
+  /** The insertion a deletion mark shares its text with, if any. */
+  insertionMark: Mark | undefined;
+  ancestors: readonly TrackedRevisionAncestor[];
+  node: Node;
+};
+/** The deletion's ancestor path, with the insertion it sits in as the outermost layer. */
+declare const enclosingInsertionAncestors: ({ insertionMark, ancestors, node }: EnclosingInsertionAncestorsOptions) => readonly TrackedRevisionAncestor[];
+//#endregion
+export { enclosingInsertionAncestors, inlineWrapperStackOf, trackedRevisionLayerOf };

package/dist/prosemirror/trackedRevisionPath.js

@@ -0,0 +1,32 @@
+import { expectInlineWrapperMarkAttrs, expectTrackedChangeMarkAttrs } from "./attrs/index.js";
+import { INLINE_WRAPPER_MARK_NAME } from "./extensions/marks/InlineWrapperExtension.js";
+//#region src/prosemirror/trackedRevisionPath.ts
+/** The wrappers `node` sits inside, outermost first; empty when it sits in none. */
+const inlineWrapperStackOf = (node) => {
+	const mark = node.marks.find((candidate) => candidate.type.name === INLINE_WRAPPER_MARK_NAME);
+	return mark ? expectInlineWrapperMarkAttrs(mark).stack : [];
+};
+/** One layer of the path used to write and enumerate a tracked run. */
+const trackedRevisionLayerOf = (mark, node) => {
+	const attrs = expectTrackedChangeMarkAttrs(mark);
+	const type = mark.type.name === "insertion" ? "insertion" : "deletion";
+	const moveType = type === "insertion" ? "moveTo" : "moveFrom";
+	return {
+		type: attrs.moveKind === moveType ? moveType : type,
+		revisionId: attrs.revisionId,
+		author: attrs.author || "Unknown",
+		...attrs.date ? { date: attrs.date } : {},
+		...attrs.utcDate ? { utcDate: attrs.utcDate } : {},
+		...attrs.initials ? { initials: attrs.initials } : {},
+		outerWrapperCount: attrs._docxOuterWrapperCount ?? inlineWrapperStackOf(node).length
+	};
+};
+/** The deletion's ancestor path, with the insertion it sits in as the outermost layer. */
+const enclosingInsertionAncestors = ({ insertionMark, ancestors, node }) => {
+	if (!insertionMark) return ancestors;
+	const attrs = expectTrackedChangeMarkAttrs(insertionMark);
+	if (ancestors.some(({ revisionId }) => revisionId === attrs.revisionId)) return ancestors;
+	return [trackedRevisionLayerOf(insertionMark, node), ...ancestors];
+};
+//#endregion
+export { enclosingInsertionAncestors, inlineWrapperStackOf, trackedRevisionLayerOf };