@stll/folio-core 0.53.0 → 0.54.0

package/dist/prosemirror/extensions/nodes/TableExtension.js

@@ -5,11 +5,13 @@ import { isValidHexColor, resolveColor } from "../../../utils/colorResolver.js";
 import { resolveTablePlacementAlignment } from "../../../utils/tablePlacement.js";
 import { textFlowCss } from "../../../utils/textDirectionFlow.js";
 import { expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs } from "../../attrs/index.js";
-import { removeTableRow } from "../../tableGridMutation.js";
+import { makeRevisionInfo } from "../../plugins/suggestionMode.js";
+import { pasteTableCells, pastedSliceWithNewTableCells } from "../../tableCellPaste.js";
+import { insertTableColumn, removeTableColumns, removeTableRow } from "../../tableGridMutation.js";
 import { createExtension, createNodeExtension } from "../create.js";
 import { panic } from "better-result";
 import { statesNoBorder } from "@stll/docx-core/model";
-import { CellSelection, TableMap, columnResizing, mergeCells, selectedRect, splitCell, tableEditing } from "prosemirror-tables";
+import { CellSelection, TableMap, columnResizing, mergeCells, selectedRect, splitCell, tableEditing, tableNodeTypes } from "prosemirror-tables";
 import { Plugin, PluginKey, Selection, TextSelection } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
 //#region src/prosemirror/extensions/nodes/TableExtension.ts
@@ -277,6 +279,7 @@ const tableRowSpec = {
 		heightRule: { default: null },
 		isHeader: { default: false },
 		hidden: { default: null },
+		_batchRowCleanup: { default: null },
 		_resolvedJustification: { default: null },
 		_originalFormatting: { default: null },
 		_tablePropertyExceptions: { default: null },
@@ -518,12 +521,12 @@ function getTableContext(state) {
 	let rowIndex;
 	let columnIndex;
 	let cellNode;
+	let cellPos;
 	for (let d = $from.depth; d > 0; d--) {
 		const node = $from.node(d);
 		if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
 			cellNode = node;
-			const rowNode = $from.node(d - 1);
-			if (rowNode.type.name === "tableRow") columnIndex = getColumnIndex(rowNode, $from.index(d - 1));
+			cellPos = $from.before(d);
 		} else if (node.type.name === "tableRow") {
 			if ($from.node(d - 1).type.name === "table") rowIndex = $from.index(d - 1);
 		} else if (node.type.name === "table") {
@@ -533,18 +536,10 @@ function getTableContext(state) {
 		}
 	}
 	if (!table) return { isInTable: false };
-	let rowCount = 0;
-	let columnCount = 0;
-	table.forEach((row) => {
-		if (row.type.name === "tableRow") {
-			rowCount++;
-			let cols = 0;
-			row.forEach((cell) => {
-				cols += Number(cell.attrs["colspan"]) || 1;
-			});
-			columnCount = Math.max(columnCount, cols);
-		}
-	});
+	const map = TableMap.get(table);
+	const rowCount = table.childCount;
+	const columnCount = map.width;
+	if (cellPos !== void 0 && tablePos !== void 0) columnIndex = map.findCell(cellPos - tablePos - 1).left;
 	const canSplitCell = cellNode !== void 0 && ((Number(cellNode.attrs["colspan"]) || 1) > 1 || (Number(cellNode.attrs["rowspan"]) || 1) > 1);
 	let cellBorderColor;
 	let cellBackgroundColor;
@@ -579,19 +574,6 @@ function getTableContext(state) {
 		...cellBackgroundColor !== void 0 ? { cellBackgroundColor } : {}
 	};
 }
-const getColumnIndex = (rowNode, targetIndex) => {
-	let columnIndex = 0;
-	let foundColumnIndex;
-	rowNode.forEach((child, _offset, index) => {
-		if (foundColumnIndex !== void 0) return;
-		if (index === targetIndex) {
-			foundColumnIndex = columnIndex;
-			return;
-		}
-		columnIndex += Number(child.attrs["colspan"]) || 1;
-	});
-	return foundColumnIndex;
-};
 function isInTableCell(state) {
 	const { $from } = state.selection;
 	for (let d = $from.depth; d > 0; d--) {
@@ -689,10 +671,12 @@ const TablePluginExtension = createExtension({
 		if (!schema.nodes["tableCell"]) panic("Missing node type: tableCell");
 		if (!schema.nodes["tableRow"]) panic("Missing node type: tableRow");
 		if (!schema.nodes["table"]) panic("Missing node type: table");
-		const nodeTypeParagraph = schema.nodes["paragraph"];
-		const nodeTypeTableCell = schema.nodes["tableCell"];
-		const nodeTypeTableRow = schema.nodes["tableRow"];
-		const nodeTypeTable = schema.nodes["table"];
+		const documentTableTypes = (documentSchema) => ({
+			paragraph: documentSchema.nodes["paragraph"] ?? panic("Missing node type: paragraph"),
+			tableCell: documentSchema.nodes["tableCell"] ?? panic("Missing node type: tableCell"),
+			tableRow: documentSchema.nodes["tableRow"] ?? panic("Missing node type: tableRow"),
+			table: documentSchema.nodes["table"] ?? panic("Missing node type: table")
+		});
 		function chainCommands(...commands) {
 			return (state, dispatch, view) => {
 				for (const cmd of commands) if (cmd(state, dispatch, view)) return true;
@@ -717,7 +701,8 @@ const TablePluginExtension = createExtension({
 				...overrides
 			};
 		}
-		function createTable(rows, cols, borderColor = "000000", contentWidthTwips = 9360) {
+		function createTable(documentSchema, rows, cols, borderColor = "000000", contentWidthTwips = 9360) {
+			const types = documentTableTypes(documentSchema);
 			const tableRows = [];
 			const colWidthTwips = Math.floor(contentWidthTwips / cols);
 			const defaultRowHeightTwips = 360;
@@ -736,22 +721,22 @@ const TablePluginExtension = createExtension({
 			for (let r = 0; r < rows; r++) {
 				const cells = [];
 				for (let c = 0; c < cols; c++) {
-					const paragraph = nodeTypeParagraph.create();
+					const paragraph = types.paragraph.create();
 					const cellAttrs = {
 						colspan: 1,
 						rowspan: 1,
 						borders: defaultBorders,
 						...statedCellWidth(colWidthTwips, "dxa")
 					};
-					cells.push(nodeTypeTableCell.create(cellAttrs, paragraph));
+					cells.push(types.tableCell.create(cellAttrs, paragraph));
 				}
-				tableRows.push(nodeTypeTableRow.create({
+				tableRows.push(types.tableRow.create({
 					height: defaultRowHeightTwips,
 					heightRule: defaultRowHeightRule
 				}, cells));
 			}
 			const columnWidths = Array.from({ length: cols }, () => colWidthTwips);
-			return nodeTypeTable.create({
+			return types.table.create({
 				columnWidths,
 				width: contentWidthTwips,
 				widthType: "dxa"
@@ -784,8 +769,31 @@ const TablePluginExtension = createExtension({
 							break;
 						}
 					}
-					const table = createTable(rows, cols, borderColor, contentWidthTwips);
-					const emptyParagraph = nodeTypeParagraph.create();
+					let table = createTable(state.schema, rows, cols, borderColor, contentWidthTwips);
+					let emptyParagraph = documentTableTypes(state.schema).paragraph.create();
+					const revision = makeRevisionInfo(state);
+					if (revision) {
+						const rowRevision = {
+							revisionId: revision.id,
+							author: revision.author,
+							date: revision.date
+						};
+						const rowsWithRevision = [];
+						table.forEach((row) => {
+							rowsWithRevision.push(row.type.create({
+								...row.attrs,
+								trIns: rowRevision
+							}, row.content));
+						});
+						table = table.type.create(table.attrs, rowsWithRevision);
+						emptyParagraph = emptyParagraph.type.create({
+							...emptyParagraph.attrs,
+							pPrMark: {
+								kind: "ins",
+								info: revision
+							}
+						});
+					}
 					const needsLeadingParagraph = state.doc.resolve(insertPos).nodeBefore?.type.name === "table";
 					const insertContent = needsLeadingParagraph ? [
 						emptyParagraph,
@@ -821,11 +829,13 @@ const TablePluginExtension = createExtension({
 			const context = getTableContext(state);
 			if (!context.isInTable || context.rowIndex === void 0 || !context.table || context.tablePos === void 0 || hasOmittedGridSlots(context.table)) return false;
 			if (!dispatch) return true;
-			const { table, tablePos, rowIndex } = context;
-			const boundaryRow = rowIndex + boundaryOffset;
-			const map = TableMap.get(table);
+			const { table, tablePos } = context;
+			const rect = selectedRect(state);
+			const boundaryRow = boundaryOffset === 0 ? rect.top : rect.bottom;
+			const { map } = rect;
 			const tableStart = tablePos + 1;
 			const tr = state.tr;
+			const paragraphType = state.schema.nodes["paragraph"];
 			const cells = [];
 			const extended = /* @__PURE__ */ new Set();
 			let lastTemplatePos = -1;
@@ -846,10 +856,11 @@ const TablePluginExtension = createExtension({
 				const templatePos = below ?? above;
 				if (templatePos === void 0 || templatePos === lastTemplatePos) continue;
 				lastTemplatePos = templatePos;
-				cells.push(nodeTypeTableCell.create(buildCellAttrsFromTemplate(table.nodeAt(templatePos)), nodeTypeParagraph.create()));
+				const template = table.nodeAt(templatePos);
+				cells.push((template?.type ?? tableNodeTypes(state.schema).cell).create(buildCellAttrsFromTemplate(template), paragraphType?.create() ?? null));
 			}
-			const rowNode = table.child(rowIndex);
-			const newRow = nodeTypeTableRow.create({
+			const rowNode = table.child(boundaryOffset === 0 ? rect.top : rect.bottom - 1);
+			const newRow = rowNode.type.create({
 				height: rowNode.attrs["height"] ?? 360,
 				heightRule: rowNode.attrs["heightRule"] ?? "atLeast"
 			}, cells);
@@ -911,176 +922,58 @@ const TablePluginExtension = createExtension({
 			}
 			return true;
 		}
-		function addColumnLeft(state, dispatch) {
+		/**
+		* Insert a column beside the selected cells: left of the first column
+		* they cover, or right of the last. The table map places the new cells,
+		* so a row whose cell in that column is held by a merge from a row above
+		* still gains its cell at the right grid column, and `w:tblGrid` gains
+		* one column the width of its neighbour instead of being rebuilt.
+		*/
+		function insertColumnBeside(state, dispatch, side) {
 			const context = getTableContext(state);
 			if (!context.isInTable || context.columnIndex === void 0 || !context.table || context.tablePos === void 0 || hasOmittedGridSlots(context.table)) return false;
 			if (dispatch) {
-				let tr = state.tr;
-				const newColumnCount = (context.columnCount ?? 1) + 1;
-				const newColWidthPercent = Math.floor(100 / newColumnCount);
-				let rowPos = context.tablePos + 1;
-				context.table.forEach((row) => {
-					if (row.type.name === "tableRow") {
-						let cellPos = rowPos + 1;
-						let colIdx = 0;
-						row.forEach((cell) => {
-							if (colIdx === context.columnIndex) {
-								const paragraph = nodeTypeParagraph.create();
-								const cellAttrs = buildCellAttrsFromTemplate(cell, {
-									colspan: 1,
-									rowspan: 1
-								});
-								Object.assign(cellAttrs, statedCellWidth(newColWidthPercent, "pct"));
-								const newCell = nodeTypeTableCell.create(cellAttrs, paragraph);
-								tr = tr.insert(tr.mapping.map(cellPos), newCell);
-							}
-							cellPos += cell.nodeSize;
-							colIdx += Number(cell.attrs["colspan"]) || 1;
+				const rect = selectedRect(state);
+				const tr = state.tr;
+				const paragraphType = state.schema.nodes["paragraph"];
+				insertTableColumn({
+					tr,
+					tablePosition: rect.tableStart - 1,
+					column: side === "left" ? rect.left : rect.right,
+					templateColumn: side === "left" ? rect.left : rect.right - 1,
+					createCell: (template) => {
+						const cellType = template?.type ?? tableNodeTypes(state.schema).cell;
+						const attrs = buildCellAttrsFromTemplate(template && (Number(template.attrs["colspan"]) || 1) === 1 ? template : null, {
+							colspan: 1,
+							rowspan: 1
 						});
-						if (context.columnIndex !== void 0 && colIdx <= context.columnIndex) {
-							const paragraph = nodeTypeParagraph.create();
-							const cellAttrs = buildCellAttrsFromTemplate(row.child(row.childCount - 1), {
-								colspan: 1,
-								rowspan: 1
-							});
-							Object.assign(cellAttrs, statedCellWidth(newColWidthPercent, "pct"));
-							const newCell = nodeTypeTableCell.create(cellAttrs, paragraph);
-							tr = tr.insert(tr.mapping.map(cellPos), newCell);
-						}
+						return cellType.create(attrs, paragraphType?.create() ?? null);
 					}
-					rowPos += row.nodeSize;
 				});
-				const updatedTable = tr.doc.nodeAt(context.tablePos);
-				if (updatedTable && updatedTable.type.name === "table") {
-					const firstRow = updatedTable.child(0);
-					if (firstRow.type.name === "tableRow") {
-						let cellPos = context.tablePos + 2;
-						firstRow.forEach((cell) => {
-							if (cell.type.name === "tableCell" || cell.type.name === "tableHeader") tr = tr.setNodeMarkup(cellPos, void 0, mergeTableCellAttrs(cell, {
-								width: newColWidthPercent,
-								widthType: "pct"
-							}));
-							cellPos += cell.nodeSize;
-						});
-					}
-					const colCount = firstRow.childCount;
-					const tableWidthTwips = expectTableAttrs(updatedTable).width ?? 9360;
-					const colWidthTwips = Math.floor(tableWidthTwips / Math.max(1, colCount));
-					tr = tr.setNodeMarkup(context.tablePos, void 0, mergeTableAttrs(updatedTable, { columnWidths: Array.from({ length: colCount }, () => colWidthTwips) }));
-				}
 				dispatch(tr.scrollIntoView());
 			}
 			return true;
 		}
+		function addColumnLeft(state, dispatch) {
+			return insertColumnBeside(state, dispatch, "left");
+		}
 		function addColumnRight(state, dispatch) {
-			const context = getTableContext(state);
-			if (!context.isInTable || context.columnIndex === void 0 || !context.table || context.tablePos === void 0 || hasOmittedGridSlots(context.table)) return false;
-			if (dispatch) {
-				let tr = state.tr;
-				const newColumnCount = (context.columnCount ?? 1) + 1;
-				const newColWidthPercent = Math.floor(100 / newColumnCount);
-				let rowPos = context.tablePos + 1;
-				context.table.forEach((row) => {
-					if (row.type.name === "tableRow") {
-						let cellPos = rowPos + 1;
-						let colIdx = 0;
-						let insertedCount = 0;
-						row.forEach((cell) => {
-							cellPos += cell.nodeSize;
-							colIdx += Number(cell.attrs["colspan"]) || 1;
-							if (insertedCount === 0 && context.columnIndex !== void 0 && colIdx > context.columnIndex) {
-								const paragraph = nodeTypeParagraph.create();
-								const cellAttrs = buildCellAttrsFromTemplate(cell, {
-									colspan: 1,
-									rowspan: 1
-								});
-								Object.assign(cellAttrs, statedCellWidth(newColWidthPercent, "pct"));
-								const newCell = nodeTypeTableCell.create(cellAttrs, paragraph);
-								tr = tr.insert(tr.mapping.map(cellPos), newCell);
-								insertedCount += 1;
-							}
-						});
-						if (insertedCount === 0) {
-							const paragraph = nodeTypeParagraph.create();
-							const cellAttrs = buildCellAttrsFromTemplate(row.child(row.childCount - 1), {
-								colspan: 1,
-								rowspan: 1
-							});
-							Object.assign(cellAttrs, statedCellWidth(newColWidthPercent, "pct"));
-							const newCell = nodeTypeTableCell.create(cellAttrs, paragraph);
-							tr = tr.insert(tr.mapping.map(cellPos), newCell);
-						}
-					}
-					rowPos += row.nodeSize;
-				});
-				const updatedTable = tr.doc.nodeAt(context.tablePos);
-				if (updatedTable && updatedTable.type.name === "table") {
-					const firstRow = updatedTable.child(0);
-					if (firstRow.type.name === "tableRow") {
-						let cellPos = context.tablePos + 2;
-						firstRow.forEach((cell) => {
-							if (cell.type.name === "tableCell" || cell.type.name === "tableHeader") tr = tr.setNodeMarkup(cellPos, void 0, mergeTableCellAttrs(cell, {
-								width: newColWidthPercent,
-								widthType: "pct"
-							}));
-							cellPos += cell.nodeSize;
-						});
-					}
-					const colCount = firstRow.childCount;
-					const tableWidthTwips = expectTableAttrs(updatedTable).width ?? 9360;
-					const colWidthTwips = Math.floor(tableWidthTwips / Math.max(1, colCount));
-					tr = tr.setNodeMarkup(context.tablePos, void 0, mergeTableAttrs(updatedTable, { columnWidths: Array.from({ length: colCount }, () => colWidthTwips) }));
-				}
-				dispatch(tr.scrollIntoView());
-			}
-			return true;
+			return insertColumnBeside(state, dispatch, "right");
 		}
+		/**
+		* Delete the columns the selected cells cover. The table map finds each
+		* row's cell in them, a merged cell reaching past them narrows, a row
+		* left with no cell of its own goes, and `w:tblGrid` loses exactly those
+		* columns.
+		*/
 		function deleteColumn(state, dispatch) {
 			const context = getTableContext(state);
 			if (!context.isInTable || context.columnIndex === void 0 || !context.table || context.tablePos === void 0 || (context.columnCount ?? 0) <= 1 || hasOmittedGridSlots(context.table)) return false;
+			const rect = selectedRect(state);
+			if (rect.right - rect.left >= rect.map.width) return false;
 			if (dispatch) {
-				let tr = state.tr;
-				const newColumnCount = (context.columnCount ?? 2) - 1;
-				const newColWidthPercent = Math.floor(100 / newColumnCount);
-				const deleteOps = [];
-				let rowPos = context.tablePos + 1;
-				context.table.forEach((row) => {
-					if (row.type.name === "tableRow") {
-						let cellPos = rowPos + 1;
-						let colIdx = 0;
-						row.forEach((cell) => {
-							const cellStart = cellPos;
-							const cellEnd = cellPos + cell.nodeSize;
-							const cellColspan = Number(cell.attrs["colspan"]) || 1;
-							if (context.columnIndex !== void 0 && colIdx <= context.columnIndex && context.columnIndex < colIdx + cellColspan) deleteOps.push({
-								start: cellStart,
-								end: cellEnd
-							});
-							cellPos = cellEnd;
-							colIdx += cellColspan;
-						});
-					}
-					rowPos += row.nodeSize;
-				});
-				for (const { start, end } of deleteOps.toReversed()) tr = tr.delete(start, end);
-				const updatedTable = tr.doc.nodeAt(context.tablePos);
-				if (updatedTable && updatedTable.type.name === "table") {
-					const firstRow = updatedTable.child(0);
-					if (firstRow.type.name === "tableRow") {
-						let cellPos = context.tablePos + 2;
-						firstRow.forEach((cell) => {
-							if (cell.type.name === "tableCell" || cell.type.name === "tableHeader") tr = tr.setNodeMarkup(cellPos, void 0, mergeTableCellAttrs(cell, {
-								width: newColWidthPercent,
-								widthType: "pct"
-							}));
-							cellPos += cell.nodeSize;
-						});
-					}
-					const colCount = firstRow.childCount;
-					const tableWidthTwips = expectTableAttrs(updatedTable).width ?? 9360;
-					const colWidthTwips = Math.floor(tableWidthTwips / Math.max(1, colCount));
-					tr = tr.setNodeMarkup(context.tablePos, void 0, mergeTableAttrs(updatedTable, { columnWidths: Array.from({ length: colCount }, () => colWidthTwips) }));
-				}
+				const tr = state.tr;
+				removeTableColumns(tr, rect.tableStart - 1, rect.left, rect.right);
 				dispatch(tr.scrollIntoView());
 			}
 			return true;
@@ -1125,16 +1018,9 @@ const TablePluginExtension = createExtension({
 			if (!context.isInTable || context.tablePos === void 0 || !context.table || context.columnIndex === void 0) return false;
 			if (dispatch) {
 				const tableStart = context.tablePos + 1;
-				const firstRow = context.table.child(0);
-				const lastRow = context.table.child(context.table.childCount - 1);
-				let firstCellPos = tableStart + 1;
-				for (let c = 0; c < context.columnIndex && c < firstRow.childCount; c++) firstCellPos += firstRow.child(c).nodeSize;
-				let lastRowPos = tableStart;
-				for (let r = 0; r < context.table.childCount - 1; r++) lastRowPos += context.table.child(r).nodeSize;
-				let lastCellPos = lastRowPos + 1;
-				for (let c = 0; c < context.columnIndex && c < lastRow.childCount; c++) lastCellPos += lastRow.child(c).nodeSize;
-				const cellSel = CellSelection.create(state.doc, firstCellPos, lastCellPos);
-				dispatch(state.tr.setSelection(cellSel));
+				const firstCell = TableMap.get(context.table).map[context.columnIndex];
+				if (firstCell === void 0) return false;
+				dispatch(state.tr.setSelection(CellSelection.colSelection(state.doc.resolve(tableStart + firstCell))));
 			}
 			return true;
 		}
@@ -2017,6 +1903,13 @@ const TablePluginExtension = createExtension({
 				return DecorationSet.empty;
 			} }
 		});
+		const tableCellPastePlugin = new Plugin({
+			key: new PluginKey("tableCellPaste"),
+			props: {
+				transformPasted: (slice) => pastedSliceWithNewTableCells(slice),
+				handlePaste: (view, _event, slice) => pasteTableCells(view.state, slice, view.dispatch)
+			}
+		});
 		return {
 			plugins: [
 				columnResizing({
@@ -2024,6 +1917,7 @@ const TablePluginExtension = createExtension({
 					cellMinWidth: 25,
 					lastColumnResizable: true
 				}),
+				tableCellPastePlugin,
 				tableEditing(),
 				activeCellPlugin
 			],

package/dist/prosemirror/extensions/types.d.ts

@@ -63,6 +63,13 @@ declare const Priority: {
   readonly Lowest: 200;
 };
 type ExtensionContext = {
+  /**
+   * The schema this runtime was built with. The documents the runtime edits
+   * may be of another instance of it (header, footer and note editors each
+   * build a runtime, and every document is parsed into the shared schema), so
+   * commands, key bindings and plugins build and compare nodes and marks with
+   * the types of the state they act on, never with types taken from here.
+   */
   schema: Schema;
 };
 type FolioCommandArguments = {

package/dist/prosemirror/hyperlinkRemoval.d.ts

@@ -0,0 +1,9 @@
+import { EditorState, Transaction } from "prosemirror-state";
+//#region src/prosemirror/hyperlinkRemoval.d.ts
+/**
+ * Remove the hyperlinks from [`from`, `to`) of `tr.doc`: directly, or, with
+ * suggestions on, as a tracked replacement of the linked text by plain text.
+ */
+declare const removeHyperlinkInRange: (state: EditorState, tr: Transaction, from: number, to: number) => Transaction;
+//#endregion
+export { removeHyperlinkInRange };

package/dist/prosemirror/hyperlinkRemoval.js

@@ -0,0 +1,129 @@
+import { BUILT_IN_STYLE_NAME } from "../docx/builtInStyles.js";
+import { getDocumentBuiltInStyles, getDocumentStyleResolver } from "./plugins/documentStyleState.js";
+import { isSuggestionModeActive, makeRevisionInfo, suggestRangeDeletion } from "./plugins/suggestionMode.js";
+import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
+import { paragraphRunStyleContextAt } from "./runStyleFormatting.js";
+//#region src/prosemirror/hyperlinkRemoval.ts
+/** Contiguous stretches of linked, not yet deleted, text in [`from`, `to`) of `doc`. */
+const linkedRanges = (doc, from, to) => {
+	const ranges = [];
+	doc.nodesBetween(from, to, (node, position) => {
+		if (!node.isText || !node.marks.some(({ type }) => type.name === "hyperlink") || node.marks.some(({ type }) => type.name === "deletion")) return true;
+		const start = Math.max(position, from);
+		const end = Math.min(position + node.nodeSize, to);
+		if (start >= end) return true;
+		const piece = {
+			from: start,
+			to: end,
+			node: node.cut(start - position, end - position)
+		};
+		const last = ranges.at(-1);
+		if (last && last.to === start) {
+			last.to = end;
+			last.pieces.push(piece);
+		} else ranges.push({
+			from: start,
+			to: end,
+			pieces: [piece]
+		});
+		return true;
+	});
+	return ranges;
+};
+/** A piece's marks once the Hyperlink character style is taken off it. */
+const withoutHyperlinkStyle = (state, doc, piece) => {
+	const styleResolver = getDocumentStyleResolver(state);
+	const builtInStyles = getDocumentBuiltInStyles(state);
+	const context = paragraphRunStyleContextAt({
+		doc,
+		pos: piece.from,
+		styleResolver
+	});
+	const previousFormatting = readAuthoredRunFormatting({
+		context,
+		marks: piece.node.marks,
+		styleResolver
+	});
+	const styleId = previousFormatting.styleId;
+	if (!(styleId !== void 0 && (builtInStyles.builtInNameOf(styleId) === BUILT_IN_STYLE_NAME.hyperlink || styleId === "Hyperlink"))) return {
+		marks: piece.node.marks,
+		previousFormatting: null
+	};
+	const { styleId: _removed, ...formatting } = previousFormatting;
+	return {
+		marks: reconcileRunFormattingMarks({
+			authoredFormatting: formatting,
+			context,
+			node: piece.node,
+			styleResolver
+		}),
+		previousFormatting
+	};
+};
+/** Replace the marks of the text at [`from`, `to`) of `tr.doc` with `marks`. */
+const setTextMarks = (tr, from, to, current, marks) => {
+	for (const mark of current) if (!mark.isInSet(marks)) tr.removeMark(from, to, mark);
+	for (const mark of marks) if (!mark.isInSet(current)) tr.addMark(from, to, mark);
+};
+/**
+* Remove the hyperlinks from [`from`, `to`) of `tr.doc`: directly, or, with
+* suggestions on, as a tracked replacement of the linked text by plain text.
+*/
+const removeHyperlinkInRange = (state, tr, from, to) => {
+	const { schema } = state;
+	const hyperlinkType = schema.marks["hyperlink"];
+	if (!hyperlinkType) return tr;
+	const insertionType = schema.marks["insertion"];
+	const deletionType = schema.marks["deletion"];
+	const propertyChangeType = schema.marks["runPropertyChange"];
+	const tracked = isSuggestionModeActive(state) && insertionType !== void 0 && deletionType !== void 0 && propertyChangeType !== void 0;
+	const revisionAttrs = () => {
+		const revision = makeRevisionInfo(state);
+		return revision ? {
+			id: revision.id,
+			author: revision.author,
+			date: revision.date
+		} : null;
+	};
+	const insertionInfo = tracked ? revisionAttrs() : null;
+	const insertion = insertionType && insertionInfo ? insertionType.create({
+		revisionId: insertionInfo.id,
+		author: insertionInfo.author,
+		date: insertionInfo.date
+	}) : null;
+	const propertyChange = (previousFormatting) => {
+		const info = revisionAttrs();
+		if (!propertyChangeType || !info) return null;
+		const change = {
+			type: "runPropertyChange",
+			info,
+			previousFormatting
+		};
+		return propertyChangeType.create({ changes: [change] });
+	};
+	const hasPendingPropertyChange = (marks) => marks.some(({ type }) => type === propertyChangeType);
+	for (const range of linkedRanges(tr.doc, from, to).toReversed()) {
+		const unlinked = range.pieces.map((piece) => ({
+			piece,
+			...withoutHyperlinkStyle(state, tr.doc, piece)
+		}));
+		if (!insertion || !deletionType) {
+			for (const { piece, marks } of unlinked) setTextMarks(tr, piece.from, piece.to, piece.node.marks, marks.filter(({ type }) => type !== hyperlinkType));
+			continue;
+		}
+		const plain = unlinked.map(({ piece, marks, previousFormatting }) => {
+			const change = previousFormatting && !hasPendingPropertyChange(marks) ? propertyChange(previousFormatting) : null;
+			const kept = marks.filter(({ type }) => type !== hyperlinkType && type !== insertionType && type !== deletionType);
+			return piece.node.mark(insertion.addToSet(change ? change.addToSet(kept) : kept));
+		});
+		tr.insert(range.to, plain);
+		for (const { piece, marks, previousFormatting } of unlinked.toReversed()) {
+			const change = previousFormatting && !hasPendingPropertyChange(piece.node.marks) ? propertyChange(previousFormatting) : null;
+			setTextMarks(tr, piece.from, piece.to, piece.node.marks, change ? change.addToSet(marks) : marks);
+		}
+		suggestRangeDeletion(state, tr, range.from, range.to);
+	}
+	return tr;
+};
+//#endregion
+export { removeHyperlinkInRange };

package/dist/prosemirror/index.d.ts

@@ -25,7 +25,8 @@ import { SelectionChangeCallback, SelectionContext, createSelectionTrackerPlugin
 import { ensureParaIdsInState } from "./extensions/features/ParaIdAllocatorExtension.js";
 import "./styles/index.js";
 import { SelectionState, extractSelectionState } from "./selectionState.js";
-import { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver } from "./plugins/documentStyles.js";
+import { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver } from "./plugins/documentStyleState.js";
+import { createDocumentStylesPlugin } from "./plugins/documentStyles.js";
 import "./plugins/index.js";
 import { insertPageBreakInView, insertTableInView, insertTableOfContentsInView } from "./insertOperations.js";
 import { TextSelection } from "prosemirror-state";

package/dist/prosemirror/index.js

@@ -15,7 +15,8 @@ import { getTableContext, isInTable as isInTableCell } from "./extensions/nodes/
 import { insertPageBreakInView, insertTableInView, insertTableOfContentsInView } from "./insertOperations.js";
 import { NO_LIST_NUMBERING_MENU, listNumberingMenuState } from "./listNumbering.js";
 import { NO_LIST_STATE, isInListState, listStateLevel, resolveListState, sameListState } from "./listState.js";
-import { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver } from "./plugins/documentStyles.js";
+import { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver } from "./plugins/documentStyleState.js";
+import { createDocumentStylesPlugin } from "./plugins/documentStyles.js";
 import { createSelectionTrackerPlugin, extractSelectionContext, getSelectionContext, selectionTrackerKey } from "./plugins/selectionTracker.js";
 import { schema, singletonManager } from "./schema/index.js";
 import { extractSelectionState } from "./selectionState.js";