@lobehub/editor 4.24.1 → 4.25.1

package/es/headless.js

@@ -1,10 +1,10 @@
 import { LITEXML_APPLY_COMMAND, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND } from "./plugins/litexml/command/symbols.js";
 import { createHeadlessEditor as createHeadlessEditor$1 } from "@lexical/headless";
 import { createEmptyHistoryState, registerHistory } from "@lexical/history";
-import { $computeTableMapSkipCellCheck, $createTableNodeWithDimensions, $createTableSelection, $deleteTableColumnAtSelection, $deleteTableRowAtSelection, $findTableNode, $insertTableColumnAtSelection, $insertTableRowAtSelection, $isSimpleTable, $isTableCellNode, $isTableNode, $isTableRowNode, $isTableSelection, TableCellNode, TableNode, TableNode as TableNode$1, TableRowNode, registerTableCellUnmergeTransform, registerTablePlugin, registerTableSelectionObserver, setScrollableTablesActive } from "@lexical/table";
+import { $computeTableMapSkipCellCheck, $createTableCellNode, $createTableNodeWithDimensions, $createTableRowNode, $createTableSelection, $deleteTableColumnAtSelection, $deleteTableRowAtSelection, $findTableNode, $insertTableColumnAtSelection, $insertTableRowAtSelection, $isSimpleTable, $isTableCellNode, $isTableNode, $isTableRowNode, $isTableSelection, TableCellNode, TableNode, TableNode as TableNode$1, TableRowNode, registerTableCellUnmergeTransform, registerTablePlugin, registerTableSelectionObserver, setScrollableTablesActive } from "@lexical/table";
 import { get, merge, template, templateSettings } from "es-toolkit/compat";
 import EventEmitter from "eventemitter3";
-import { $applyNodeReplacement, $caretFromPoint, $createLineBreakNode, $createNodeSelection, $createParagraphNode, $createRangeSelection, $createTextNode, $getCaretRange, $getCharacterOffsets, $getChildCaret, $getNearestNodeFromDOMNode, $getNodeByKey, $getPreviousSelection, $getRoot, $getSelection, $insertNodes, $isBlockElementNode, $isDecoratorNode, $isElementNode, $isLineBreakNode, $isNodeSelection, $isRangeSelection, $isRootNode, $isRootOrShadowRoot, $isTextNode, $isTextPointCaret, $nodesOfType, $normalizeSelection__EXPERIMENTAL, $parseSerializedNode, $setSelection, COLLABORATION_TAG, COMMAND_PRIORITY_CRITICAL, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_HIGH, COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, CONTROLLED_TEXT_INSERTION_COMMAND, COPY_COMMAND, DecoratorNode, ElementNode, FORMAT_TEXT_COMMAND, HISTORIC_TAG, HISTORY_MERGE_TAG, HISTORY_PUSH_TAG, INDENT_CONTENT_COMMAND, INSERT_LINE_BREAK_COMMAND, INSERT_PARAGRAPH_COMMAND, INSERT_TAB_COMMAND, IS_BOLD, IS_CODE, IS_ITALIC, IS_STRIKETHROUGH, IS_SUBSCRIPT, IS_SUPERSCRIPT, IS_UNDERLINE, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_LEFT_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, KEY_DOWN_COMMAND, KEY_ENTER_COMMAND, KEY_TAB_COMMAND, OUTDENT_CONTENT_COMMAND, PASTE_COMMAND, ParagraphNode, REDO_COMMAND, SELECTION_CHANGE_COMMAND, SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, TEXT_TYPE_TO_FORMAT, TextNode, UNDO_COMMAND, createCommand, createEditor, getNearestEditorFromDOMNode, isHTMLElement, isModifierMatch, resetRandomKey, setDOMUnmanaged } from "lexical";
+import { $applyNodeReplacement, $caretFromPoint, $createLineBreakNode, $createNodeSelection, $createParagraphNode, $createRangeSelection, $createTextNode, $getCaretRange, $getCharacterOffsets, $getChildCaret, $getNearestNodeFromDOMNode, $getNodeByKey, $getPreviousSelection, $getRoot, $getSelection, $insertNodes, $isBlockElementNode, $isDecoratorNode, $isElementNode, $isLineBreakNode, $isNodeSelection, $isRangeSelection, $isRootNode, $isRootOrShadowRoot, $isTextNode, $isTextPointCaret, $nodesOfType, $normalizeSelection__EXPERIMENTAL, $parseSerializedNode, $setSelection, COLLABORATION_TAG, COMMAND_PRIORITY_CRITICAL, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_HIGH, COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, CONTROLLED_TEXT_INSERTION_COMMAND, COPY_COMMAND, DecoratorNode, ElementNode, FORMAT_TEXT_COMMAND, HISTORIC_TAG, HISTORY_MERGE_TAG, HISTORY_PUSH_TAG, INDENT_CONTENT_COMMAND, INSERT_LINE_BREAK_COMMAND, INSERT_PARAGRAPH_COMMAND, INSERT_TAB_COMMAND, IS_BOLD, IS_CODE, IS_ITALIC, IS_STRIKETHROUGH, IS_SUBSCRIPT, IS_SUPERSCRIPT, IS_UNDERLINE, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_LEFT_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, KEY_DOWN_COMMAND, KEY_ENTER_COMMAND, KEY_TAB_COMMAND, OUTDENT_CONTENT_COMMAND, PASTE_COMMAND, ParagraphNode, REDO_COMMAND, SELECTION_CHANGE_COMMAND, SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, SELECT_ALL_COMMAND, TEXT_TYPE_TO_FORMAT, TextNode, UNDO_COMMAND, createCommand, createEditor, getNearestEditorFromDOMNode, isHTMLElement, isModifierMatch, resetRandomKey, setDOMUnmanaged } from "lexical";
 import { $createHeadingNode, $createQuoteNode, $isHeadingNode, $isQuoteNode, HeadingNode, QuoteNode, registerRichText } from "@lexical/rich-text";
 import createDebug from "debug";
 import { $filter, $findMatchingParent, $getNearestBlockElementAncestorOrThrow, $getNearestNodeOfType, $insertNodeToNearestRoot, $wrapNodeInElement, CAN_USE_DOM, IS_APPLE as isApple, addClassNamesToElement, calculateZoomLevel, isHTMLAnchorElement, isHTMLElement as isHTMLElement$1, mergeRegister } from "@lexical/utils";
@@ -46,6 +46,12 @@ var locale_default = {
 		replace: "Replace"
 	},
 	link: {
+		copy: "Copy Link",
+		copySuccess: "Link copied",
+		convertToCard: "Convert to Card",
+		convertToIframe: "Convert to Iframe",
+		convertToLink: "Convert to Link",
+		convertToSchema: "Convert to Schema",
 		edit: "Edit Link",
 		editLinkTitle: "Link",
 		editTextTitle: "Text",
@@ -76,6 +82,14 @@ var locale_default = {
 		insertColumnRight: "Insert {{count}} column(s) to the right",
 		insertRowAbove: "Insert {{count}} row(s) above",
 		insertRowBelow: "Insert {{count}} row(s) below"
+	},
+	toc: {
+		ariaLabel: "Table of contents",
+		empty: "No headings",
+		expand: "Expand table of contents",
+		pin: "Pin table of contents",
+		title: "TOC",
+		unpin: "Unpin table of contents"
 	}
 };
 //#endregion
@@ -804,26 +818,46 @@ var Kernel = class Kernel extends EventEmitter {
 		return this.editor || null;
 	}
 	destroy() {
-		unregisterEditorKernel(this.themes[EDITOR_THEME_KEY]);
+		const editor = this.editor;
+		const editorId = this.getEditorId();
 		this.logger.info(`🗑️ Destroying editor with ${this.pluginsInstances.length} plugins`);
+		if (editor) try {
+			editor.setRootElement(null);
+		} catch (error) {
+			this.logger.warn("Failed to detach editor root during destroy:", error);
+		}
+		unregisterEditorKernel(editorId);
 		try {
-			this.editor?.setEditorState(createEmptyEditorState());
+			editor?.setEditorState(createEmptyEditorState());
 		} catch (error) {
 			this.logger.warn("Failed to reset editor state during destroy:", error);
 		}
-		this.dataTypeMap.clear();
+		this.unregisterRootLifecycle?.();
+		this.unregisterRootLifecycle = void 0;
+		let destroyError;
 		this.pluginsInstances.forEach((plugin) => {
-			if (plugin.destroy) plugin.destroy();
+			try {
+				plugin.destroy?.();
+			} catch (error) {
+				destroyError ??= error;
+			}
 		});
 		this.pluginsInstances = [];
-		this.beforeEditorInitHooks = [];
+		this.dataTypeMap.clear();
+		this.decorators = {};
 		this.nodeTransforms = [];
+		this.nodes = [];
+		this.beforeEditorInitHooks = [];
 		this.rootClassNames.clear();
 		this.serviceMap.clear();
-		this.decorators = {};
-		this.themes = {};
+		this.themes = { [EDITOR_THEME_KEY]: generateEditorId() };
+		this.historyState = createEmptyHistoryState();
+		this._commands.clear();
+		this._commandsClean.clear();
+		this.editor = void 0;
 		this.headlessEditor = false;
 		this.logger.info("✅ Editor destroyed");
+		if (destroyError) throw destroyError;
 	}
 	getRootElement() {
 		if (this.headlessEditor) return null;
@@ -831,12 +865,23 @@ var Kernel = class Kernel extends EventEmitter {
 	}
 	setRootElement(dom, editable = true) {
 		if (this.editor) {
-			if (this.headlessEditor) throw new Error("Headless editor cannot be attached to a root element.");
+			if (this.headlessEditor) {
+				if (dom === null) return this.editor;
+				throw new Error("Headless editor cannot be attached to a root element.");
+			}
 			this.logger.warn("[Editor] Editor is already initialized, updating root element only");
+			if (dom) registerEditorKernel(this.getEditorId(), this);
 			this.editor.setRootElement(dom);
-			this.applyRootClassNames(dom);
+			if (dom) {
+				this.editor.setEditable(editable);
+				this.applyRootClassNames(dom);
+			}
 			return this.editor;
 		}
+		if (dom === null) {
+			unregisterEditorKernel(this.getEditorId());
+			return null;
+		}
 		if (this.pluginsInstances.length === 0) {
 			this.logger.info(`🔌 Initializing ${this.plugins.length} plugins`);
 			for (const plugin of this.plugins) {
@@ -847,7 +892,7 @@ var Kernel = class Kernel extends EventEmitter {
 		this.runBeforeEditorInitLifecycle();
 		const resolvedNodes = this.resolveNodesForInitialization();
 		this.logger.info(`📝 Creating editor with ${resolvedNodes.length} nodes`);
-		registerEditorKernel(this.themes[EDITOR_THEME_KEY], this);
+		registerEditorKernel(this.getEditorId(), this);
 		const editor = this.editor = createEditor({
 			__kernel: this,
 			editable,
@@ -860,9 +905,9 @@ var Kernel = class Kernel extends EventEmitter {
 			theme: this.themes
 		});
 		this.headlessEditor = false;
+		this.registerRootLifecycle(editor);
 		this.editor.setRootElement(dom);
 		this.applyRootClassNames(dom);
-		registerEvent(editor, dom);
 		this.pluginsInstances.forEach((plugin) => {
 			plugin.onInit?.(editor);
 		});
@@ -902,6 +947,7 @@ var Kernel = class Kernel extends EventEmitter {
 			theme: this.themes
 		});
 		this.headlessEditor = false;
+		this.registerRootLifecycle(editor);
 		this.pluginsInstances.forEach((plugin) => {
 			plugin.onInit?.(editor);
 		});
@@ -955,6 +1001,9 @@ var Kernel = class Kernel extends EventEmitter {
 			this.historyState.current = null;
 		}
 		datasource.read(this.editor, content, options);
+		this.pluginsInstances.forEach((plugin) => {
+			plugin.onDocumentChange?.(type, content, options);
+		});
 		this.emit("documentChange", type, content);
 		this.logger.debug(`📥 Set ${type} document`);
 	}
@@ -1219,6 +1268,34 @@ var Kernel = class Kernel extends EventEmitter {
 			if (currentRootElement) currentRootElement.classList.remove(...classNames);
 		};
 	}
+	registerRootListener(listener) {
+		if (!this.editor || this.headlessEditor) return noop;
+		return this.editor.registerRootListener(listener);
+	}
+	getEditorId() {
+		return this.themes[EDITOR_THEME_KEY];
+	}
+	registerRootLifecycle(editor) {
+		this.unregisterRootLifecycle?.();
+		let rootEventCleanup;
+		const clearRootEvent = () => {
+			rootEventCleanup?.();
+			rootEventCleanup = void 0;
+		};
+		const unregisterRootListener = editor.registerRootListener((rootElement) => {
+			clearRootEvent();
+			if (!rootElement) {
+				unregisterEditorKernel(this.getEditorId());
+				return;
+			}
+			registerEditorKernel(this.getEditorId(), this);
+			rootEventCleanup = registerEvent(editor, rootElement);
+		});
+		this.unregisterRootLifecycle = () => {
+			clearRootEvent();
+			unregisterRootListener();
+		};
+	}
 	runBeforeEditorInitLifecycle() {
 		for (const hook of this.beforeEditorInitHooks) hook();
 	}
@@ -1597,8 +1674,309 @@ function registerCursorNode(editor) {
 	}, COMMAND_PRIORITY_HIGH));
 }
 //#endregion
+//#region src/plugins/litexml/diff-validation.ts
+const ACTIONABLE_DIFF_TYPES = /* @__PURE__ */ new Set([
+	"add",
+	"remove",
+	"modify",
+	"listItemAdd",
+	"listItemModify",
+	"listItemRemove"
+]);
+const isActionableDiff = (node) => node?.type === "diff" && ACTIONABLE_DIFF_TYPES.has(node.diffType || "");
+const isElementNode = (node) => Array.isArray(node.children);
+const cloneNode = (node) => structuredClone(node);
+function hasActionableDiffDescendant(node) {
+	return (node.children || []).some((child) => isActionableDiff(child) || hasActionableDiffDescendant(child));
+}
+/**
+* Validate the serialized public tree. Paths use serialized node ids, not
+* Lexical's private node map, so this remains stable across JSON reloads.
+*/
+function collectIllegalNestedDiffPaths(root) {
+	const violations = [];
+	const visit = (node, ancestors, path) => {
+		const actionableAncestor = [...ancestors].reverse().find(isActionableDiff);
+		const rowDiffAncestor = [...ancestors].reverse().find((ancestor) => ancestor.type === "table-row-diff");
+		const allowedCellDiffChild = ancestors.at(-1)?.type === "table-cell-diff" && isActionableDiff(node);
+		if (isActionableDiff(node) && actionableAncestor && !allowedCellDiffChild) violations.push(`${path}:diff-inside-diff`);
+		if (rowDiffAncestor) {
+			if (node.type === "table-cell-diff") violations.push(`${path}:cell-inside-row-diff`);
+			else if (isActionableDiff(node)) violations.push(`${path}:diff-inside-row-diff`);
+		}
+		if (actionableAncestor) {
+			if (node.type === "table-cell-diff") violations.push(`${path}:cell-diff-inside-diff`);
+			else if (node.type === "table-row-diff") violations.push(`${path}:row-diff-inside-diff`);
+		}
+		if (!isElementNode(node)) return;
+		node.children?.forEach((child) => {
+			visit(child, [...ancestors, node], `${path}/${child.id || child.type || "node"}`);
+		});
+	};
+	visit(root, [], root.id || root.type || "root");
+	return violations;
+}
+function findNewIllegalDiffPaths(previous, projected) {
+	const previousCounts = /* @__PURE__ */ new Map();
+	collectIllegalNestedDiffPaths(previous.root).forEach((path) => {
+		previousCounts.set(path, (previousCounts.get(path) || 0) + 1);
+	});
+	const newPaths = [];
+	const projectedCounts = /* @__PURE__ */ new Map();
+	collectIllegalNestedDiffPaths(projected.root).forEach((path) => {
+		const count = (projectedCounts.get(path) || 0) + 1;
+		projectedCounts.set(path, count);
+		if (count > (previousCounts.get(path) || 0)) newPaths.push(path);
+	});
+	return newPaths;
+}
+function findNodeLocation(root, id, ancestors = []) {
+	if (root.id === id) return {
+		ancestors,
+		index: -1,
+		node: root,
+		parent: null
+	};
+	for (const [index, child] of (root.children || []).entries()) {
+		if (child.id === id) return {
+			ancestors: [...ancestors, root],
+			index,
+			node: child,
+			parent: root
+		};
+		const nested = findNodeLocation(child, id, [...ancestors, root]);
+		if (nested) return nested;
+	}
+	return null;
+}
+function replaceNode(location, replacements) {
+	if (!location.parent || location.index < 0) return;
+	location.parent.children?.splice(location.index, 1, ...replacements);
+}
+function createDiff(diffType, children) {
+	return {
+		children,
+		diffType,
+		type: "diff"
+	};
+}
+function createDiffContent(side, children) {
+	return {
+		children,
+		side,
+		type: "diff-content"
+	};
+}
+function projectModifyTarget(root, incoming) {
+	if (!incoming.id) return;
+	const location = findNodeLocation(root, incoming.id);
+	if (!location) return;
+	const target = location.node;
+	const next = cloneNode(incoming);
+	if (target.type === "tablerow" && location.parent?.type === "table") {
+		replaceNode(location, [{
+			children: cloneNode(target.children || []),
+			diffType: "remove",
+			type: "table-row-diff"
+		}, {
+			children: cloneNode(next.children || []),
+			diffType: "add",
+			type: "table-row-diff"
+		}]);
+		return;
+	}
+	if (target.type === "tablecell" || target.type === "table-cell-diff") {
+		const existingDiff = (target.children || []).find((child) => child.type === "diff");
+		if (existingDiff && target.type === "table-cell-diff") {
+			existingDiff.children = cloneNode(next.children || []);
+			return;
+		}
+		const after = existingDiff?.children?.find((child) => child.type === "diff-content" && child.side === "after");
+		if (existingDiff?.diffType === "modify" && after) {
+			after.children = cloneNode(next.children || []);
+			return;
+		}
+		target.children = [createDiff("modify", [createDiffContent("before", cloneNode(target.children || [])), createDiffContent("after", cloneNode(next.children || []))])];
+		return;
+	}
+	if (location.ancestors.some(isActionableDiff)) {
+		replaceNode(location, [next]);
+		return;
+	}
+	replaceNode(location, [createDiff("modify", [cloneNode(target), next])]);
+}
+function projectRemoveTarget(root, id) {
+	const location = findNodeLocation(root, id);
+	if (!location) return;
+	if (location.ancestors.some(isActionableDiff)) {
+		replaceNode(location, []);
+		return;
+	}
+	const target = location.node;
+	if (target.type === "tablecell" || target.type === "table-cell-diff") {
+		replaceNode(location, [{
+			children: [createDiff("remove", cloneNode(target.children || []))],
+			diffType: "remove",
+			type: "table-cell-diff"
+		}]);
+		return;
+	}
+	if (target.type === "tablerow" && location.parent?.type === "table") {
+		replaceNode(location, [{
+			children: cloneNode(target.children || []),
+			diffType: "remove",
+			type: "table-row-diff"
+		}]);
+		return;
+	}
+	replaceNode(location, [createDiff("remove", [cloneNode(target)])]);
+}
+function projectInsert(root, operation, readXml) {
+	const referenceId = "beforeId" in operation ? operation.beforeId : operation.afterId;
+	const reference = referenceId === "root" ? null : findNodeLocation(root, referenceId)?.node || null;
+	const location = referenceId === "root" ? {
+		ancestors: [root],
+		index: "beforeId" in operation ? 0 : (root.children || []).length - 1,
+		node: root.children?.[0] || root,
+		parent: root
+	} : findNodeLocation(root, referenceId);
+	if (!location) return;
+	const incoming = (readXml(operation.litexml).root?.children || []).map(cloneNode);
+	if (incoming.length === 0 || !location.parent) return;
+	const insertAt = "beforeId" in operation ? location.index : location.index + 1;
+	if (incoming.every((node) => node.type === "tablecell") && reference?.type === "tablecell") {
+		location.parent.children?.splice(insertAt, 0, ...incoming.map((node) => ({
+			children: [createDiff("add", cloneNode(node.children || []))],
+			diffType: "add",
+			type: "table-cell-diff"
+		})));
+		return;
+	}
+	if (incoming.every((node) => node.type === "tablerow") && reference?.type === "tablerow") {
+		location.parent.children?.splice(insertAt, 0, ...incoming.map((node) => ({
+			children: cloneNode(node.children || []),
+			diffType: "add",
+			type: "table-row-diff"
+		})));
+		return;
+	}
+	const actionableAncestor = location.ancestors.findLast(isActionableDiff);
+	const isInlineReference = [
+		"text",
+		"span",
+		"link",
+		"autolink",
+		"linebreak"
+	].includes(reference?.type || "");
+	const blockAncestor = [...location.ancestors].reverse().find((node) => [
+		"paragraph",
+		"heading",
+		"listitem",
+		"table",
+		"tablerow",
+		"tablecell"
+	].includes(node.type || ""));
+	if (!actionableAncestor && blockAncestor && hasActionableDiffDescendant(blockAncestor)) {
+		const wrapped = createDiff("modify", [cloneNode(blockAncestor), cloneNode(blockAncestor)]);
+		const blockLocation = findNodeLocation(root, blockAncestor.id || "");
+		if (blockLocation) replaceNode(blockLocation, [wrapped]);
+		return;
+	}
+	if (actionableAncestor && !isInlineReference) {
+		const originLocation = actionableAncestor.id ? findNodeLocation(root, actionableAncestor.id) : null;
+		if (originLocation?.parent && originLocation.index >= 0) {
+			const originInsertAt = "beforeId" in operation ? originLocation.index : originLocation.index + 1;
+			originLocation.parent.children?.splice(originInsertAt, 0, ...incoming.map((node) => createDiff("add", [node])));
+			return;
+		}
+	}
+	const inserted = actionableAncestor && isInlineReference ? incoming : incoming.map((node) => createDiff("add", [node]));
+	location.parent.children?.splice(insertAt, 0, ...inserted);
+}
+/**
+* Project one operation on a cloned serialized tree. The real Lexical tree is
+* untouched; callers compare illegal paths before/after and only dispatch safe
+* operations to the live editor.
+*/
+function projectLiteXmlOperation(document, operation, readXml) {
+	const projected = cloneNode(document);
+	if (operation.action === "modify") (Array.isArray(operation.litexml) ? operation.litexml : [operation.litexml]).forEach((xml) => {
+		(readXml(xml).root?.children || []).forEach((child) => {
+			projectModifyTarget(projected.root, child);
+		});
+	});
+	else if (operation.action === "remove") projectRemoveTarget(projected.root, operation.id);
+	else projectInsert(projected.root, operation, readXml);
+	return projected;
+}
+//#endregion
+//#region src/plugins/litexml/node/DiffContentNode.ts
+/** Groups one side of a modify diff so it can contain any number of block nodes. */
+var DiffContentNode = class DiffContentNode extends ElementNode {
+	static getType() {
+		return "diff-content";
+	}
+	static clone(node) {
+		return new DiffContentNode(node.__side, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createDiffContentNode(serializedNode.side).updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return null;
+	}
+	constructor(side, key) {
+		super(key);
+		this.__side = side;
+	}
+	get side() {
+		return this.__side;
+	}
+	setSide(side) {
+		this.getWritable().__side = side;
+		return this;
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode).setSide(serializedNode.side);
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			side: this.__side,
+			type: DiffContentNode.getType(),
+			version: 1
+		};
+	}
+	createDOM(_config, _editor) {
+		const element = document.createElement("div");
+		element.dataset.diffContent = this.__side;
+		return element;
+	}
+	updateDOM(previousNode, dom) {
+		if (previousNode.__side !== this.__side) dom.dataset.diffContent = this.__side;
+		return false;
+	}
+	exportDOM(_editor) {
+		const element = document.createElement("div");
+		element.dataset.diffContent = this.__side;
+		return { element };
+	}
+	canBeEmpty() {
+		return true;
+	}
+	isInline() {
+		return false;
+	}
+};
+function $createDiffContentNode(side) {
+	return $applyNodeReplacement(new DiffContentNode(side));
+}
+function $isDiffContentNode(node) {
+	return node instanceof DiffContentNode;
+}
+//#endregion
 //#region src/plugins/litexml/node/DiffNode.ts
-/** DiffNode - contains two block children: original and modified */
+/** DiffNode - contains the original and modified sides, optionally grouped into multiple blocks. */
 var DiffNode = class DiffNode extends CardLikeElementNode {
 	static getType() {
 		return "diff";
@@ -1690,6 +2068,83 @@ var DiffNode = class DiffNode extends CardLikeElementNode {
 function $createDiffNode(diffType = "unchanged") {
 	return $applyNodeReplacement(new DiffNode(diffType));
 }
+function $isDiffNode(node) {
+	return node instanceof DiffNode;
+}
+//#endregion
+//#region src/plugins/litexml/node/TableCellDiffNode.ts
+/**
+* Review-only table cell. The diff state lives on a TableCellNode subclass so
+* TableRowNode children remain cells throughout staging and approval.
+*/
+var TableCellDiffNode = class TableCellDiffNode extends TableCellNode {
+	static getType() {
+		return "table-cell-diff";
+	}
+	static clone(node) {
+		const clone = new TableCellDiffNode(node.__diffType, node.__changeId, node.getHeaderStyles(), node.getColSpan(), node.getWidth(), node.__key);
+		clone.__rowSpan = node.__rowSpan;
+		clone.__backgroundColor = node.__backgroundColor;
+		clone.__verticalAlign = node.__verticalAlign;
+		return clone;
+	}
+	static importJSON(serializedNode) {
+		return $createTableCellDiffNode(serializedNode.diffType, serializedNode.changeId, serializedNode.headerState, serializedNode.colSpan, serializedNode.width).updateFromJSON(serializedNode);
+	}
+	constructor(diffType, changeId, headerState, colSpan, width, key) {
+		super(headerState, colSpan, width, key);
+		this.__diffType = diffType;
+		this.__changeId = changeId;
+	}
+	createDOM(config) {
+		const element = super.createDOM(config);
+		const theme = config.theme.tableCellDiff;
+		if (typeof theme === "string" && theme) element.classList.add(theme);
+		this.syncDOMState(element);
+		return element;
+	}
+	updateDOM(prevNode) {
+		return super.updateDOM(prevNode) || prevNode.__diffType !== this.__diffType || prevNode.__changeId !== this.__changeId;
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			changeId: this.__changeId,
+			diffType: this.__diffType,
+			type: TableCellDiffNode.getType(),
+			version: 1
+		};
+	}
+	getChangeId() {
+		return this.getLatest().__changeId;
+	}
+	getDiffType() {
+		return this.getLatest().__diffType;
+	}
+	setChangeId(changeId) {
+		this.getWritable().__changeId = changeId;
+		return this;
+	}
+	setDiffType(diffType) {
+		this.getWritable().__diffType = diffType;
+		return this;
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode).setDiffType(serializedNode.diffType).setChangeId(serializedNode.changeId);
+	}
+	syncDOMState(element) {
+		element.contentEditable = "false";
+		element.dataset.diffType = this.__diffType;
+		if (this.__changeId) element.dataset.diffChangeId = this.__changeId;
+		else delete element.dataset.diffChangeId;
+	}
+};
+function $createTableCellDiffNode(diffType, changeId, headerState, colSpan, width) {
+	return $applyNodeReplacement(new TableCellDiffNode(diffType, changeId, headerState, colSpan, width));
+}
+function $isTableCellDiffNode(node) {
+	return node instanceof TableCellDiffNode;
+}
 //#endregion
 //#region src/plugins/litexml/utils/index.ts
 const getNumericId$1 = (id) => {
@@ -1748,11 +2203,333 @@ function charToId(char) {
 	return String((parseInt(char, 36) - startId + maxId) * modInverse % maxId);
 }
 //#endregion
+//#region src/plugins/litexml/table-cell-diff.ts
+function copyCellStructure(source, target) {
+	target.setRowSpan(source.getRowSpan());
+	target.setBackgroundColor(source.getBackgroundColor());
+	target.setVerticalAlign(source.getVerticalAlign());
+}
+function $createTableCellDiffFromCell(editor, cell, diffType, changeId) {
+	const diffCell = $createTableCellDiffNode(diffType, changeId, cell.getHeaderStyles(), cell.getColSpan(), cell.getWidth());
+	copyCellStructure(cell, diffCell);
+	const diff = $createDiffNode(diffType);
+	diff.append(...cell.getChildren().map((child) => $cloneNode(child, editor)));
+	diffCell.append(diff);
+	return diffCell;
+}
+function $createPlainTableCellFromDiff(editor, cell) {
+	const plainCell = $createTableCellNode(cell.getHeaderStyles(), cell.getColSpan(), cell.getWidth());
+	copyCellStructure(cell, plainCell);
+	const diff = cell.getFirstChild();
+	if (diff instanceof DiffNode) plainCell.append(...diff.getChildren().map((child) => $cloneNode(child, editor)));
+	else plainCell.append(...cell.getChildren().map((child) => $cloneNode(child, editor)));
+	return plainCell;
+}
+function $getTableForCell(cell) {
+	const row = cell.getParent();
+	if (!$isTableRowNode(row)) return null;
+	const table = row.getParent();
+	return $isTableNode(table) ? table : null;
+}
+function $getTableCellColumnIndex(cell) {
+	const row = cell.getParent();
+	if (!$isTableRowNode(row)) return -1;
+	let index = 0;
+	for (const sibling of row.getChildren()) {
+		if (sibling === cell) return index;
+		if ($isTableCellNode(sibling)) index += sibling.getColSpan();
+	}
+	return -1;
+}
+function $getLogicalRowWidth(cell) {
+	const row = cell.getParent();
+	if (!$isTableRowNode(row)) return 0;
+	return row.getChildren().reduce((total, child) => total + ($isTableCellNode(child) ? child.getColSpan() : 0), 0);
+}
+function $getTableCellDiffGroup(cell) {
+	const changeId = cell.getChangeId();
+	const table = $getTableForCell(cell);
+	if (!changeId || !table) return [cell];
+	return $nodesOfType(TableCellDiffNode).filter((candidate) => candidate.getChangeId() === changeId && candidate.getDiffType() === cell.getDiffType() && $getTableForCell(candidate) === table);
+}
+function $updateTableWidthsForCellInsertion(table, rowWidthBefore, columnIndex, insertedSpan) {
+	const currentWidths = table.getColWidths() || Array.from({ length: rowWidthBefore }, () => 250);
+	if (rowWidthBefore < currentWidths.length) return;
+	const fallback = currentWidths[Math.max(0, columnIndex - 1)] || 250;
+	const next = [...currentWidths];
+	next.splice(columnIndex, 0, ...Array.from({ length: insertedSpan }, () => fallback));
+	table.setColWidths(next);
+}
+function $removeTableWidthsForCompleteCellGroup(table, group, columnIndex, span) {
+	const rows = table.getChildren().filter($isTableRowNode);
+	const rowKeys = new Set(group.map((cell) => cell.getParent()?.getKey()));
+	if (rows.length !== rowKeys.size) return;
+	const widths = table.getColWidths();
+	if (!widths) return;
+	const next = [...widths];
+	next.splice(columnIndex, span);
+	table.setColWidths(next);
+}
+function $shrinkTableWidthsAfterCellRemoval(table, columnIndex, span) {
+	const widths = table.getColWidths();
+	if (!widths) return;
+	if (table.getChildren().reduce((max, row) => {
+		if (!$isTableRowNode(row)) return max;
+		return Math.max(max, row.getChildren().reduce((total, cell) => total + ($isTableCellNode(cell) ? cell.getColSpan() : 0), 0));
+	}, 0) > widths.length - span) return;
+	const next = [...widths];
+	next.splice(columnIndex, span);
+	table.setColWidths(next);
+}
+function $getMaximumLogicalColumnCount(table) {
+	return table.getChildren().reduce((maximum, row) => {
+		if (!$isTableRowNode(row)) return maximum;
+		const columnCount = row.getChildren().reduce((total, cell) => {
+			return total + ($isTableCellNode(cell) ? cell.getColSpan() : 0);
+		}, 0);
+		return Math.max(maximum, columnCount);
+	}, 0);
+}
+function $hasLegacyTableCellDiffs() {
+	return $nodesOfType(DiffNode).some((diff) => {
+		return (diff.diffType === "add" || diff.diffType === "remove") && $isTableRowNode(diff.getParent()) && diff.getChildren().some($isTableCellNode);
+	});
+}
+function $hasIncompleteTableWidths() {
+	return $nodesOfType(TableNode).some((table) => {
+		return (table.getColWidths()?.length || 0) < $getMaximumLogicalColumnCount(table);
+	});
+}
+/**
+* Migrates the old `TableRow > DiffNode > TableCellNode` representation into
+* cell-shaped diff nodes and makes sure the table has a width for every
+* logical column. Safe to call repeatedly.
+*/
+function $normalizeLegacyTableCellDiffs(editor) {
+	let changed = false;
+	$nodesOfType(DiffNode).forEach((legacyDiff) => {
+		const diffType = legacyDiff.diffType;
+		if (diffType !== "add" && diffType !== "remove" || !$isTableRowNode(legacyDiff.getParent())) return;
+		const cells = legacyDiff.getChildren().filter($isTableCellNode);
+		if (cells.length === 0) return;
+		const changeId = `legacy-table-cell-${legacyDiff.getKey()}`;
+		cells.forEach((cell) => {
+			legacyDiff.insertBefore($createTableCellDiffFromCell(editor, cell, diffType, changeId));
+		});
+		legacyDiff.remove();
+		changed = true;
+	});
+	$nodesOfType(TableNode).forEach((table) => {
+		const requiredWidthCount = $getMaximumLogicalColumnCount(table);
+		const currentWidths = table.getColWidths() || [];
+		if (currentWidths.length >= requiredWidthCount) return;
+		const fallback = currentWidths.at(-1) || 250;
+		table.setColWidths([...currentWidths, ...Array.from({ length: requiredWidthCount - currentWidths.length }, () => fallback)]);
+		changed = true;
+	});
+	return changed;
+}
+function registerLegacyTableCellDiffNormalization(editor) {
+	let destroyed = false;
+	let scheduled = false;
+	const unregister = editor.registerUpdateListener(() => {
+		if (scheduled || destroyed) return;
+		scheduled = true;
+		queueMicrotask(() => {
+			scheduled = false;
+			if (destroyed) return;
+			if (!editor.getEditorState().read(() => $hasLegacyTableCellDiffs() || $hasIncompleteTableWidths())) return;
+			editor.update(() => {
+				$normalizeLegacyTableCellDiffs(editor);
+			}, { discrete: true });
+		});
+	});
+	return () => {
+		destroyed = true;
+		unregister();
+	};
+}
+//#endregion
+//#region src/plugins/litexml/node/TableRowDiffNode.ts
+/**
+* A review-only table row. Keeping the diff state on a TableRowNode subclass
+* preserves Lexical's table invariant: TableNode children are always rows.
+*/
+var TableRowDiffNode = class TableRowDiffNode extends TableRowNode {
+	static getType() {
+		return "table-row-diff";
+	}
+	static clone(node) {
+		return new TableRowDiffNode(node.__diffType, node.__changeId, node.getHeight(), node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createTableRowDiffNode(serializedNode.diffType, serializedNode.changeId, serializedNode.height).updateFromJSON(serializedNode);
+	}
+	constructor(diffType, changeId, height, key) {
+		super(height, key);
+		this.__diffType = diffType;
+		this.__changeId = changeId;
+	}
+	createDOM(config) {
+		const element = super.createDOM(config);
+		const theme = config.theme.tableRowDiff;
+		if (typeof theme === "string" && theme) element.classList.add(theme);
+		this.syncDOMState(element);
+		return element;
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			changeId: this.__changeId,
+			diffType: this.__diffType,
+			type: TableRowDiffNode.getType(),
+			version: 1
+		};
+	}
+	getChangeId() {
+		return this.getLatest().__changeId;
+	}
+	getDiffType() {
+		return this.getLatest().__diffType;
+	}
+	setChangeId(changeId) {
+		this.getWritable().__changeId = changeId;
+		return this;
+	}
+	setDiffType(diffType) {
+		this.getWritable().__diffType = diffType;
+		return this;
+	}
+	updateDOM(prevNode) {
+		return super.updateDOM(prevNode) || prevNode.__diffType !== this.__diffType || prevNode.__changeId !== this.__changeId;
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode).setDiffType(serializedNode.diffType).setChangeId(serializedNode.changeId);
+	}
+	syncDOMState(element) {
+		element.dataset.diffType = this.__diffType;
+		if (this.__changeId) element.dataset.diffChangeId = this.__changeId;
+		else delete element.dataset.diffChangeId;
+		element.contentEditable = "false";
+	}
+};
+function $createTableRowDiffNode(diffType, changeId, height) {
+	return $applyNodeReplacement(new TableRowDiffNode(diffType, changeId, height));
+}
+function $isTableRowDiffNode(node) {
+	return node instanceof TableRowDiffNode;
+}
+//#endregion
+//#region src/plugins/litexml/table-row-diff.ts
+function $areTableRowStructuresCompatible(previousRow, nextRow) {
+	const previousCells = previousRow.getChildren();
+	const nextCells = nextRow.getChildren();
+	if (previousCells.length !== nextCells.length || !previousCells.every($isTableCellNode) || !nextCells.every($isTableCellNode)) return false;
+	return previousCells.every((previousCell, index) => {
+		const nextCell = nextCells[index];
+		return $isTableCellNode(nextCell) && previousCell.getColSpan() === nextCell.getColSpan() && previousCell.getRowSpan() === nextCell.getRowSpan();
+	});
+}
+function $createTableRowDiffFromRow(editor, row, diffType, changeId) {
+	const source = $cloneNode(row, editor);
+	const diffRow = $createTableRowDiffNode(diffType, changeId, row.getHeight());
+	diffRow.append(...source.getChildren());
+	return diffRow;
+}
+function $createPlainTableRowFromDiff(editor, row) {
+	const plainRow = $createTableRowNode(row.getHeight());
+	plainRow.append(...row.getChildren().map((child) => $cloneNode(child, editor)));
+	return plainRow;
+}
+function $getTableRowDiffPair(node) {
+	const changeId = node.getChangeId();
+	if (!changeId) return null;
+	const matchingRows = $nodesOfType(TableRowDiffNode).filter((candidate) => candidate.getChangeId() === changeId);
+	if (matchingRows.length !== 2) return null;
+	const remove = matchingRows.find((candidate) => candidate.getDiffType() === "remove");
+	const add = matchingRows.find((candidate) => candidate.getDiffType() === "add");
+	if (!remove || !add) return null;
+	const parent = remove.getParent();
+	if (!$isTableNode(parent) || add.getParent() !== parent || remove.getNextSibling() !== add || !$areTableRowStructuresCompatible(remove, add)) return null;
+	return {
+		add,
+		remove
+	};
+}
+function $normalizeTableRowDiffPairs() {
+	const rows = $nodesOfType(TableRowDiffNode);
+	const groups = /* @__PURE__ */ new Map();
+	rows.forEach((row) => {
+		const changeId = row.getChangeId();
+		if (!changeId) return;
+		const group = groups.get(changeId) || [];
+		group.push(row);
+		groups.set(changeId, group);
+	});
+	let changed = false;
+	groups.forEach((group) => {
+		if (group.length === 2 ? $getTableRowDiffPair(group[0]) : null) return;
+		group.forEach((row) => row.setChangeId());
+		changed = true;
+	});
+	return changed;
+}
+function registerTableRowDiffNormalization(editor) {
+	let destroyed = false;
+	let scheduled = false;
+	const unregister = editor.registerUpdateListener(() => {
+		if (scheduled || destroyed) return;
+		scheduled = true;
+		queueMicrotask(() => {
+			scheduled = false;
+			if (destroyed) return;
+			if (!editor.getEditorState().read(() => {
+				return $nodesOfType(TableRowDiffNode).some((row) => row.getChangeId() && !$getTableRowDiffPair(row));
+			})) return;
+			editor.update(() => {
+				$normalizeTableRowDiffPairs();
+			});
+		});
+	});
+	return () => {
+		destroyed = true;
+		unregister();
+	};
+}
+//#endregion
 //#region src/plugins/litexml/command/index.ts
 const logger$7 = createDebugLogger("plugin", "litexml");
 function toArrayXml(litexml) {
 	return Array.isArray(litexml) ? litexml : [litexml];
 }
+function hasNewIllegalDiffs(previous, projected) {
+	return findNewIllegalDiffPaths(previous, projected);
+}
+function projectOperation(dataSource, document, operation) {
+	try {
+		const projected = projectLiteXmlOperation(document, operation, (xml) => dataSource.readLiteXMLToInode(xml));
+		const newIllegalDiffs = hasNewIllegalDiffs(document, projected);
+		if (newIllegalDiffs.length > 0) {
+			logger$7.warn("⚠️ Skipping operation with illegal nested diff", newIllegalDiffs);
+			return null;
+		}
+		return projected;
+	} catch (error) {
+		logger$7.error("❌ Failed to preflight LiteXML operation:", error);
+		return null;
+	}
+}
+function toProjectionOperation(operation) {
+	if (operation.action === "remove") return {
+		...operation,
+		id: charToId(operation.id)
+	};
+	if (operation.action === "insert") return {
+		...operation,
+		..."beforeId" in operation ? { beforeId: operation.beforeId === "root" ? "root" : charToId(operation.beforeId) } : { afterId: operation.afterId === "root" ? "root" : charToId(operation.afterId) }
+	};
+	return operation;
+}
 function tryParseChild(child, editor) {
 	try {
 		const oldNode = $getNodeByKey(child.id);
@@ -1769,15 +2546,56 @@ function tryParseChild(child, editor) {
 	}
 }
 function handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNodeMap, editor) {
-	const oldBlock = $closest(oldNode, (node) => node.isInline() === false);
-	if (!oldBlock) throw new Error("Old block node not found for diffing.");
-	if ($closest(oldNode, (node) => node.getType() === DiffNode.getType())) {
-		oldNode.replace(newNode, false);
+	if ($isTableRowNode(oldNode) || $isTableRowNode(newNode)) {
+		if (!$isTableRowNode(oldNode) || !$isTableRowNode(newNode) || !$isTableNode(oldNode.getParent()) || !$areTableRowStructuresCompatible(oldNode, newNode)) {
+			logger$7.error(`❌ Invalid table row modification for row ${oldNode.getKey()}.`);
+			return;
+		}
+		const changeId = `${oldNode.getKey()}:${newNode.getKey()}`;
+		const removeRow = $createTableRowDiffFromRow(editor, oldNode, "remove", changeId);
+		const addRow = $createTableRowDiffFromRow(editor, newNode, "add", changeId);
+		oldNode.replace(removeRow, false);
+		removeRow.insertAfter(addRow);
 		return;
 	}
-	if (oldNode === oldBlock) {
-		const diffNode = $createDiffNode("modify");
-		diffNode.append($cloneNode(oldBlock, editor), newNode);
+	if ($isTableCellNode(oldNode) && $isTableCellNode(newNode)) {
+		const existingDiff = oldNode.getChildren().find($isDiffNode);
+		if (existingDiff) {
+			if ($isTableCellDiffNode(oldNode)) {
+				existingDiff.clear();
+				newNode.getChildren().forEach((child) => {
+					existingDiff.append($cloneNode(child, editor));
+				});
+				return;
+			}
+			const after = existingDiff.getChildren().find((child) => $isDiffContentNode(child) && child.side === "after");
+			if (existingDiff.diffType === "modify" && after && $isDiffContentNode(after)) {
+				after.clear();
+				newNode.getChildren().forEach((child) => {
+					after.append($cloneNode(child, editor));
+				});
+				return;
+			}
+		}
+		const before = $createDiffContentNode("before");
+		const after = $createDiffContentNode("after");
+		oldNode.getChildren().forEach((child) => before.append($cloneNode(child, editor)));
+		newNode.getChildren().forEach((child) => after.append($cloneNode(child, editor)));
+		const diffNode = $createDiffNode("modify");
+		diffNode.append(before, after);
+		oldNode.clear();
+		oldNode.append(diffNode);
+		return;
+	}
+	const oldBlock = $closest(oldNode, (node) => node.isInline() === false);
+	if (!oldBlock) throw new Error("Old block node not found for diffing.");
+	if ($closest(oldNode, (node) => node.getType() === DiffNode.getType())) {
+		oldNode.replace(newNode, false);
+		return;
+	}
+	if (oldNode === oldBlock) {
+		const diffNode = $createDiffNode("modify");
+		diffNode.append($cloneNode(oldBlock, editor), newNode);
 		oldNode.replace(diffNode, false);
 	} else {
 		if (!modifyBlockNodes.has(oldBlock.getKey())) {
@@ -1852,8 +2670,15 @@ function registerLiteXMLCommand(editor, dataSource) {
 			else acc.push(cur);
 			return acc;
 		}, []);
+		let projectedDocument = getKernelFromEditor(editor).getDocument("json");
+		const safePayload = resultPayload.filter((item) => {
+			const nextProjection = projectOperation(dataSource, projectedDocument, toProjectionOperation(item));
+			if (!nextProjection) return false;
+			projectedDocument = nextProjection;
+			return true;
+		});
 		try {
-			resultPayload.forEach((item) => {
+			safePayload.forEach((item) => {
 				const { action } = item;
 				switch (action) {
 					case "modify": {
@@ -1882,14 +2707,39 @@ function registerLiteXMLCommand(editor, dataSource) {
 		}
 	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_APPLY_COMMAND, (payload) => {
 		const { litexml, delay } = payload;
-		handleModify(editor, dataSource, toArrayXml(litexml), delay);
+		const arrayXml = toArrayXml(litexml);
+		if (!delay) {
+			handleModify(editor, dataSource, arrayXml, delay);
+			return false;
+		}
+		const operation = {
+			action: "modify",
+			litexml
+		};
+		if (projectOperation(dataSource, getKernelFromEditor(editor).getDocument("json"), toProjectionOperation(operation))) handleModify(editor, dataSource, arrayXml, delay);
 		return false;
 	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_REMOVE_COMMAND, (payload) => {
 		const { id, delay } = payload;
-		handleRemove(editor, charToId(id), delay);
+		const key = charToId(id);
+		if (!delay) {
+			handleRemove(editor, key, delay);
+			return false;
+		}
+		const operation = {
+			action: "remove",
+			id
+		};
+		if (projectOperation(dataSource, getKernelFromEditor(editor).getDocument("json"), toProjectionOperation(operation))) handleRemove(editor, key, delay);
 		return false;
 	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_INSERT_COMMAND, (payload) => {
-		handleInsert(editor, payload, dataSource);
+		if (!payload.delay) {
+			handleInsert(editor, payload, dataSource);
+			return false;
+		}
+		if (projectOperation(dataSource, getKernelFromEditor(editor).getDocument("json"), toProjectionOperation({
+			action: "insert",
+			...payload
+		}))) handleInsert(editor, payload, dataSource);
 		return false;
 	}, COMMAND_PRIORITY_EDITOR));
 }
@@ -1942,9 +2792,32 @@ function handleRemove(editor, key, delay) {
 		const node = $getNodeByKey(key);
 		if (!node) return;
 		if (!delay) {
+			if ($isTableCellNode(node)) {
+				const table = $getTableForCell(node);
+				const columnIndex = $getTableCellColumnIndex(node);
+				const span = node.getColSpan();
+				node.remove();
+				if (table && columnIndex >= 0) $shrinkTableWidthsAfterCellRemoval(table, columnIndex, span);
+				return;
+			}
 			node.remove();
 			return;
 		}
+		if ($isTableCellNode(node)) {
+			const table = $getTableForCell(node);
+			const columnIndex = $getTableCellColumnIndex(node);
+			if (!table || columnIndex < 0) {
+				logger$7.error(`❌ Table cell ${node.getKey()} is not attached to a valid table row.`);
+				return;
+			}
+			const changeId = `${table.getKey()}:column:${columnIndex}`;
+			node.replace($createTableCellDiffFromCell(editor, node, "remove", changeId), false);
+			return;
+		}
+		if ($isTableRowNode(node) && $isTableNode(node.getParent())) {
+			node.replace($createTableRowDiffFromRow(editor, node, "remove"), false);
+			return;
+		}
 		if (node.isInline() === false) {
 			const originDiffNode = $closest(node, (node) => node.getType() === DiffNode.getType());
 			if (originDiffNode) {
@@ -2006,6 +2879,37 @@ function handleInsert(editor, payload, dataSource) {
 			else referenceNode = $getNodeByKey(charToId(payload.afterId));
 			if (!referenceNode) throw new Error("Reference node not found for insertion.");
 			const newNodes = inode.root.children.map((child) => $parseSerializedNodeImpl(child, editor));
+			const referencesTableCell = $isTableCellNode(referenceNode);
+			const insertsOnlyTableCells = newNodes.length > 0 && newNodes.every($isTableCellNode);
+			if (referencesTableCell || insertsOnlyTableCells) {
+				if (!referencesTableCell || !insertsOnlyTableCells) {
+					logger$7.error("❌ Table cells can only be inserted next to another cell in the same row.");
+					return;
+				}
+				const cellReference = referenceNode;
+				const table = $getTableForCell(cellReference);
+				const referenceIndex = $getTableCellColumnIndex(cellReference);
+				if (!table || referenceIndex < 0) {
+					logger$7.error("❌ Table cell insertion requires a valid table parent.");
+					return;
+				}
+				const rowWidthBefore = $getLogicalRowWidth(cellReference);
+				const insertionIndex = isBefore ? referenceIndex : referenceIndex + cellReference.getColSpan();
+				$updateTableWidthsForCellInsertion(table, rowWidthBefore, insertionIndex, newNodes.reduce((total, node) => total + ($isTableCellNode(node) ? node.getColSpan() : 0), 0));
+				let spanOffset = 0;
+				const cells = newNodes.map((node) => {
+					const result = delay ? $createTableCellDiffFromCell(editor, node, "add", `${table.getKey()}:column:${insertionIndex + spanOffset}`) : node;
+					spanOffset += node.getColSpan();
+					return result;
+				});
+				if (isBefore) cells.reverse().forEach((cell) => {
+					referenceNode = referenceNode.insertBefore(cell);
+				});
+				else cells.forEach((cell) => {
+					referenceNode = referenceNode.insertAfter(cell);
+				});
+				return;
+			}
 			if (!delay) {
 				if (isBefore) newNodes.reverse().forEach((node) => {
 					referenceNode = referenceNode.insertBefore(node);
@@ -2015,6 +2919,25 @@ function handleInsert(editor, payload, dataSource) {
 				});
 				return;
 			}
+			const referencesTableRow = $isTableRowNode(referenceNode);
+			const insertsOnlyTableRows = newNodes.every($isTableRowNode);
+			if (referencesTableRow || insertsOnlyTableRows) {
+				if (!referencesTableRow || !insertsOnlyTableRows || !$isTableNode(referenceNode.getParent())) {
+					logger$7.error("❌ Table rows can only be inserted next to another row in the same table.");
+					return;
+				}
+				if (isBefore) newNodes.reverse().forEach((node) => {
+					if (!$isTableRowNode(node)) return;
+					const diffRow = $createTableRowDiffFromRow(editor, node, "add");
+					referenceNode = referenceNode.insertBefore(diffRow);
+				});
+				else newNodes.forEach((node) => {
+					if (!$isTableRowNode(node)) return;
+					const diffRow = $createTableRowDiffFromRow(editor, node, "add");
+					referenceNode = referenceNode.insertAfter(diffRow);
+				});
+				return;
+			}
 			if (isBefore) {
 				if (referenceNode.isInline() === false) {
 					const originDiffNode = $closest(referenceNode, (node) => node.getType() === DiffNode.getType());
@@ -2076,11 +2999,69 @@ function handleInsert(editor, payload, dataSource) {
 }
 //#endregion
 //#region src/plugins/litexml/command/diffCommand.ts
-function doAction(node, action) {
+function doTableRowAction(editor, node, action) {
+	const pair = $getTableRowDiffPair(node);
+	if (pair) {
+		const survivingRow = action === 1 ? pair.add : pair.remove;
+		const discardedRow = action === 1 ? pair.remove : pair.add;
+		const plainRow = $createPlainTableRowFromDiff(editor, survivingRow);
+		discardedRow.remove();
+		survivingRow.replace(plainRow, false);
+		plainRow.selectStart();
+		return;
+	}
+	if (node.getDiffType() === "remove") {
+		if (action === 1) node.remove();
+		else {
+			const plainRow = $createPlainTableRowFromDiff(editor, node);
+			node.replace(plainRow, false);
+			plainRow.selectStart();
+		}
+		return;
+	}
+	if (action === 1) {
+		const plainRow = $createPlainTableRowFromDiff(editor, node);
+		node.replace(plainRow, false);
+		plainRow.selectStart();
+	} else node.remove();
+}
+function doTableCellAction(editor, node, action) {
+	const group = $getTableCellDiffGroup(node);
+	const table = $getTableForCell(node);
+	const columnIndex = $getTableCellColumnIndex(node);
+	const span = node.getColSpan();
+	if (node.getDiffType() === "add" && action === 1 || node.getDiffType() === "remove" && action === 0) {
+		group.forEach((cell) => cell.replace($createPlainTableCellFromDiff(editor, cell), false));
+		return;
+	}
+	if (table && columnIndex >= 0) {
+		const widthCount = table.getColWidths()?.length;
+		$removeTableWidthsForCompleteCellGroup(table, group, columnIndex, span);
+		group.forEach((cell) => cell.remove());
+		if (table.getColWidths()?.length === widthCount) $shrinkTableWidthsAfterCellRemoval(table, columnIndex, span);
+		return;
+	}
+	group.forEach((cell) => cell.remove());
+}
+function doAction(editor, node, action) {
+	if ($isTableRowDiffNode(node)) {
+		doTableRowAction(editor, node, action);
+		return;
+	}
+	const parent = node.getParent();
+	if ($isTableCellDiffNode(parent)) {
+		doTableCellAction(editor, parent, action);
+		return;
+	}
 	if (node.diffType === "modify") {
 		const children = node.getChildren();
-		if (action === 1) node.replace(children[1], false).selectEnd();
-		else if (action === 0) node.replace(children[0], false).selectEnd();
+		const selectedChild = action === 1 ? children[1] : children[0];
+		if ($isDiffContentNode(selectedChild)) {
+			const parent = node.getParentOrThrow();
+			selectedChild.getChildren().forEach((child) => node.insertBefore(child));
+			node.remove();
+			if ($isElementNode(parent)) parent.selectEnd();
+		} else if (selectedChild) node.replace(selectedChild, false).selectEnd();
 	}
 	if (node.diffType === "remove") {
 		if (action === 1) node.remove();
@@ -2092,7 +3073,10 @@ function doAction(node, action) {
 	if (node.diffType === "add") {
 		if (action === 1) {
 			const children = node.getChildren();
-			node.replace(children[0], false).selectEnd();
+			const parent = node.getParentOrThrow();
+			children.forEach((child) => node.insertBefore(child));
+			node.remove();
+			if ($isElementNode(parent)) parent.selectEnd();
 		} else if (action === 0) node.remove();
 	}
 	if (node.diffType === "listItemModify") {
@@ -2138,23 +3122,37 @@ function doAction(node, action) {
 function registerLiteXMLDiffCommand(editor) {
 	return mergeRegister(editor.registerCommand(LITEXML_DIFFNODE_COMMAND, (payload) => {
 		const { action, nodeKey } = payload;
-		const node = editor.getEditorState().read(() => {
-			return $getNodeByKey(nodeKey);
-		});
-		if (!node) return false;
 		editor.update(() => {
-			doAction(node, action);
+			const node = $getNodeByKey(nodeKey);
+			if (!(node instanceof DiffNode) && !$isTableRowDiffNode(node)) return;
+			doAction(editor, node, action);
 		});
 		return false;
 	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_DIFFNODE_ALL_COMMAND, (payload) => {
 		const { action } = payload;
-		const nodes = editor.getEditorState().read(() => {
-			return Array.from(editor._editorState._nodeMap.values()).filter((n) => n instanceof DiffNode && !!n.getParent());
+		const nodeKeys = editor.getEditorState().read(() => {
+			return Array.from(editor._editorState._nodeMap.values()).filter((node) => (node instanceof DiffNode || $isTableRowDiffNode(node)) && !!node.getParent()).map((node) => node.getKey());
 		});
-		if (!nodes.length) return false;
+		if (!nodeKeys.length) return false;
 		editor.update(() => {
-			nodes.forEach((node) => {
-				doAction(node, action);
+			const handled = /* @__PURE__ */ new Set();
+			nodeKeys.forEach((nodeKey) => {
+				if (handled.has(nodeKey)) return;
+				const node = $getNodeByKey(nodeKey);
+				if (!(node instanceof DiffNode) && !$isTableRowDiffNode(node)) return;
+				const pair = $isTableRowDiffNode(node) ? $getTableRowDiffPair(node) : null;
+				if (pair) {
+					handled.add(pair.remove.getKey());
+					handled.add(pair.add.getKey());
+				} else {
+					const parent = node instanceof DiffNode ? node.getParent() : null;
+					if ($isTableCellDiffNode(parent)) $getTableCellDiffGroup(parent).forEach((cell) => {
+						const diff = cell.getFirstChild();
+						if (diff instanceof DiffNode) handled.add(diff.getKey());
+					});
+					handled.add(nodeKey);
+				}
+				doAction(editor, node, action);
 			});
 		});
 		return false;
@@ -2587,8 +3585,29 @@ function convertMdastToLexical(node, index, ctx, markdownReaders = {}, parentTyp
 							return ret;
 						}
 						if (child.value.startsWith("<!--") && child.value.endsWith("-->")) return ret;
-						const tag = child.value.replaceAll(/^<\/?|>$/g, "");
+						const tag = getHtmlTagName$1(child.value);
 						const isEndTag = child.value.startsWith("</");
+						const pairedTag = child.value.match(/^<\s*([a-z0-9-]+)\b[^>]*>([\s\S]*)<\/\s*\1\s*>$/i);
+						if (!isEndTag && pairedTag) {
+							const reader = markdownReaders["html"];
+							const htmlChildren = pairedTag[2] ? [INodeHelper.createTextNode(pairedTag[2])] : [];
+							if (Array.isArray(reader)) for (const element of reader) {
+								const inode = element(child, htmlChildren, index);
+								if (inode) {
+									ret.push(inode);
+									return ret;
+								}
+							}
+							else if (typeof reader === "function") {
+								const inode = reader(child, htmlChildren, index);
+								if (inode) {
+									ret.push(inode);
+									return ret;
+								}
+							}
+							ret.push(INodeHelper.createTextNode(child.value));
+							return ret;
+						}
 						if (selfClosingHtmlTags.has(tag)) {
 							const reader = markdownReaders["html"];
 							if (Array.isArray(reader)) for (const element of reader) {
@@ -2675,6 +3694,9 @@ function convertMdastToLexical(node, index, ctx, markdownReaders = {}, parentTyp
 		}
 	}
 }
+function getHtmlTagName$1(value) {
+	return value.match(/^<\/?\s*([a-z0-9-]+)/i)?.[1]?.toLowerCase() || value.replaceAll(/^<\/?|>$/g, "");
+}
 function registerDefaultReaders(markdownReaders) {
 	if (!markdownReaders["root"]) markdownReaders["root"] = (node, children) => {
 		return {
@@ -3552,6 +4574,7 @@ function detectCodeLanguage(code) {
 //#region src/plugins/markdown/plugin/index.ts
 const DEFAULT_PASTE_MARKDOWN_AUTO_CONVERT_THRESHOLD = 5;
 const RICH_HTML_SELECTOR = "strong,em,b,i,h1,h2,h3,h4,h5,h6,ul,ol,table,img,blockquote,pre>code,a[href]";
+const normalizeMarkdownForClipboard = (markdown) => markdown.replace(/\r?\n$/, "");
 const MARKDOWN_DETECTION_RULES = [
 	{
 		name: "headers",
@@ -3748,8 +4771,9 @@ const MarkdownPlugin = class extends KernelPlugin {
 			if (!clipboardData) return false;
 			const selection = $getSelection();
 			if (!selection || selection.isCollapsed()) return false;
-			const markdown = this.markdownDataSource.write(editor, { selection: true });
-			if (!markdown) return false;
+			const rawMarkdown = this.markdownDataSource.write(editor, { selection: true });
+			if (!rawMarkdown) return false;
+			const markdown = normalizeMarkdownForClipboard(rawMarkdown);
 			event.preventDefault();
 			const data = $getClipboardDataFromSelection(selection);
 			setLexicalClipboardDataTransfer(clipboardData, data);
@@ -3835,14 +4859,23 @@ const LitexmlPlugin = class extends KernelPlugin {
 		super();
 		this.kernel = kernel;
 		this.config = config;
-		kernel.registerThemes({ diffNode: config?.theme || "editor_diffNode" });
+		kernel.registerThemes({
+			diffNode: config?.theme || "editor_diffNode",
+			tableRowDiff: config?.tableRowDiffTheme || "editor_tableRowDiff",
+			tableCellDiff: config?.tableCellDiffTheme || "editor_tableCellDiff"
+		});
 		const litexmlService = new LitexmlService();
 		this.service = litexmlService;
 		kernel.registerService(ILitexmlService, litexmlService);
 		this.datasource = new LitexmlDataSource("litexml", (serviceId) => {
 			return kernel.requireService(serviceId);
 		}, litexmlService);
-		kernel.registerNodes([DiffNode]);
+		kernel.registerNodes([
+			DiffNode,
+			DiffContentNode,
+			TableRowDiffNode,
+			TableCellDiffNode
+		]);
 		kernel.registerDecorator(DiffNode.getType(), {
 			queryDOM: (el) => el.querySelector(".toolbar"),
 			render: (node, editor) => {
@@ -3854,6 +4887,8 @@ const LitexmlPlugin = class extends KernelPlugin {
 	onInit(editor) {
 		this.register(registerLiteXMLCommand(editor, this.datasource));
 		this.register(registerLiteXMLDiffCommand(editor));
+		this.register(registerLegacyTableCellDiffNormalization(editor));
+		this.register(registerTableRowDiffNormalization(editor));
 		this.register(editor.registerNodeTransform(DiffNode, (node) => {
 			if (node.diffType === "modify" && node.getChildrenSize() === 1) node.setDiffType("remove");
 		}));
@@ -3878,11 +4913,14 @@ const LitexmlPlugin = class extends KernelPlugin {
 			const diffNode = node;
 			const lines = [];
 			switch (diffNode.diffType) {
-				case "modify":
-					nodeToXML(diffNode.getChildAtIndex(1), lines, indent);
+				case "modify": {
+					const after = diffNode.getChildAtIndex(1);
+					if ($isDiffContentNode(after)) after.getChildren().forEach((child) => nodeToXML(child, lines, indent));
+					else nodeToXML(after, lines, indent);
 					break;
+				}
 				case "add":
-					nodeToXML(diffNode.getChildAtIndex(0), lines, indent);
+					diffNode.getChildren().forEach((child) => nodeToXML(child, lines, indent));
 					break;
 				case "remove": break;
 				case "listItemModify": diffNode.getChildAtIndex(1).getChildren().forEach((child) => {
@@ -3891,16 +4929,49 @@ const LitexmlPlugin = class extends KernelPlugin {
 			}
 			return { lines };
 		});
+		this.service.registerXMLWriter(TableRowDiffNode.getType(), (node, ctx) => {
+			if (!$isTableRowDiffNode(node)) return false;
+			if (node.getDiffType() === "remove") return { lines: [] };
+			return ctx.createXmlNode("tr", {});
+		});
+		this.service.registerXMLWriter(TableCellDiffNode.getType(), (node, ctx) => {
+			if (!$isTableCellDiffNode(node)) return false;
+			if (node.getDiffType() === "remove") return { lines: [] };
+			const attributes = {};
+			if (node.getColSpan() > 1) attributes.colSpan = String(node.getColSpan());
+			if (node.getRowSpan() > 1) attributes.rowSpan = String(node.getRowSpan());
+			if (node.getBackgroundColor()) attributes.backgroundColor = node.getBackgroundColor();
+			return ctx.createXmlNode("td", attributes);
+		});
 	}
 	registerMarkdown() {
-		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(DiffNode.getType(), (ctx, node) => {
+		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
+		markdownService?.registerMarkdownWriter(TableCellDiffNode.getType(), (ctx, node) => {
+			if (!$isTableCellDiffNode(node)) return false;
+			if (node.getDiffType() === "remove") return true;
+			if (!node.getNextSibling()) ctx.wrap("|", "|");
+			else ctx.wrap("|", "");
+			return true;
+		});
+		markdownService?.registerMarkdownWriter(TableRowDiffNode.getType(), (ctx, node) => {
+			if (!$isTableRowDiffNode(node)) return false;
+			if (node.getDiffType() === "remove") return true;
+			const parent = node.getParent();
+			if (!$isTableNode(parent)) return true;
+			if (node.getPreviousSiblings().some((sibling) => !$isTableRowDiffNode(sibling) || sibling.getDiffType() !== "remove")) ctx.wrap("", "\n");
+			else ctx.wrap("", `\n${parent.getColWidths()?.map(() => "|:--").join("")}|\n`);
+		});
+		markdownService?.registerMarkdownWriter(DiffNode.getType(), (ctx, node) => {
 			const diffNode = node;
 			switch (diffNode.diffType) {
-				case "modify":
-					ctx.processChild(ctx, diffNode.getChildAtIndex(1));
+				case "modify": {
+					const after = diffNode.getChildAtIndex(1);
+					if ($isDiffContentNode(after)) after.getChildren().forEach((child) => ctx.processChild(ctx, child));
+					else ctx.processChild(ctx, after);
 					break;
+				}
 				case "add":
-					ctx.processChild(ctx, diffNode.getChildAtIndex(0));
+					diffNode.getChildren().forEach((child) => ctx.processChild(ctx, child));
 					break;
 				case "remove": break;
 				case "listItemModify": diffNode.getChildAtIndex(1).getChildren().forEach((child) => {
@@ -4414,6 +5485,84 @@ function runPasteHandlers(ctx, handlers) {
 	return false;
 }
 //#endregion
+//#region src/plugins/common/plugin/progressive-select-all.ts
+const COLLAPSIBLE_NODE_TYPE = "collapsible";
+function registerProgressiveSelectAll(editor) {
+	return editor.registerCommand(SELECT_ALL_COMMAND, () => {
+		const selection = $getSelection();
+		if ($isTableSelection(selection)) return $expandTableSelection(selection);
+		if (!$isRangeSelection(selection)) return false;
+		const anchorCell = $findNearestNode(selection.anchor.getNode(), $isTableCellNode);
+		const focusCell = $findNearestNode(selection.focus.getNode(), $isTableCellNode);
+		if (anchorCell && focusCell && anchorCell.is(focusCell)) {
+			const table = $findNearestNode(anchorCell, $isTableNode);
+			if (table) {
+				const tableSelection = $createTableSelection();
+				tableSelection.set(table.getKey(), anchorCell.getKey(), anchorCell.getKey());
+				$setSelection(tableSelection);
+				return true;
+			}
+		}
+		const anchorCollapsible = $findCollapsibleAncestor(selection.anchor.getNode());
+		const focusCollapsible = $findCollapsibleAncestor(selection.focus.getNode());
+		if (!anchorCollapsible || !focusCollapsible || !anchorCollapsible.is(focusCollapsible)) return false;
+		if ($isEntireElementSelected(selection, anchorCollapsible)) $selectDocument();
+		else anchorCollapsible.select(0, anchorCollapsible.getChildrenSize());
+		return true;
+	}, COMMAND_PRIORITY_HIGH);
+}
+function $expandTableSelection(selection) {
+	const table = $getNodeByKey(selection.tableKey);
+	if (!$isTableNode(table)) return false;
+	const cells = $getTableCells(table);
+	if (!cells) return false;
+	const selectedCellKeys = new Set(selection.getNodes().filter($isTableCellNode).map((cell) => cell.getKey()));
+	if (cells.keys.every((key) => selectedCellKeys.has(key))) {
+		$selectDocument();
+		return true;
+	}
+	const tableSelection = $createTableSelection();
+	tableSelection.set(table.getKey(), cells.first.getKey(), cells.last.getKey());
+	$setSelection(tableSelection);
+	return true;
+}
+function $getTableCells(table) {
+	if (!$isTableNode(table)) return null;
+	const [tableMap] = $computeTableMapSkipCellCheck(table, null, null);
+	const entries = tableMap.flat().filter(Boolean);
+	const first = entries[0]?.cell;
+	const last = entries.at(-1)?.cell;
+	if (!first || !last) return null;
+	return {
+		first,
+		keys: Array.from(new Set(entries.map(({ cell }) => cell.getKey()))),
+		last
+	};
+}
+function $findNearestNode(node, predicate) {
+	let current = node;
+	while (current) {
+		if (predicate(current)) return current;
+		current = current.getParent();
+	}
+	return null;
+}
+function $findCollapsibleAncestor(node) {
+	return $findNearestNode(node, (candidate) => $isElementNode(candidate) && candidate.getType() === COLLAPSIBLE_NODE_TYPE);
+}
+function $isEntireElementSelected(selection, element) {
+	const startOffset = 0;
+	const endOffset = element.getChildrenSize();
+	return $isPointAt(selection.anchor, element, startOffset) && $isPointAt(selection.focus, element, endOffset) || $isPointAt(selection.focus, element, startOffset) && $isPointAt(selection.anchor, element, endOffset);
+}
+function $isPointAt(point, element, offset) {
+	return point.key === element.getKey() && point.offset === offset && point.type === "element";
+}
+function $selectDocument() {
+	const root = $getRoot();
+	root.select(0, root.getChildrenSize());
+}
+//#endregion
 //#region src/plugins/common/plugin/register.ts
 const logger$3 = createDebugLogger("plugin", "common");
 function resolveElement(element, isBackward, focusOffset) {
@@ -4429,7 +5578,9 @@ function resolveElement(element, isBackward, focusOffset) {
 			block = parent;
 		}
 	}
-	return block.getChildAtIndex(isBackward ? offset - 1 : offset);
+	const childIndex = isBackward ? offset - 1 : offset;
+	if (childIndex < 0 || childIndex >= block.getChildrenSize()) return null;
+	return block.getChildAtIndex(childIndex);
 }
 function isCodeNodeLastLine(focusNode) {
 	if (!$isCodeHighlightNode(focusNode)) return false;
@@ -4474,7 +5625,55 @@ function $isSelectionAtEndOfRoot(selection) {
 	const focus = selection.focus;
 	return focus.key === "root" && focus.offset === $getRoot().getChildrenSize();
 }
-function registerHeaderBackspace(editor) {
+function $isSelectionInList(selection) {
+	return Boolean($closest(selection.focus.getNode(), (node) => $isListNode(node) || $isListItemNode(node)));
+}
+function $getLeadingQuoteNode(selection) {
+	const anchor = selection.anchor;
+	if (anchor.offset !== 0) return false;
+	let node = anchor.getNode();
+	let current = node;
+	let quoteNode = null;
+	while (current) {
+		if ($isQuoteNode(current)) {
+			quoteNode = current;
+			break;
+		}
+		current = current.getParent();
+	}
+	if (!quoteNode) return false;
+	while (node !== quoteNode) {
+		if (node.getIndexWithinParent() !== 0) return false;
+		const parent = node.getParent();
+		if (!parent) return false;
+		node = parent;
+	}
+	return quoteNode;
+}
+function $unwrapQuoteNode(quoteNode) {
+	const children = quoteNode.getChildren();
+	if (children.length === 0) {
+		const paragraphNode = $createParagraphNode();
+		quoteNode.replace(paragraphNode);
+		paragraphNode.select(0, 0);
+		return;
+	}
+	let firstNode = null;
+	for (const child of children) {
+		if ($isElementNode(child)) {
+			quoteNode.insertBefore(child);
+			firstNode ||= child;
+			continue;
+		}
+		const paragraphNode = $createParagraphNode();
+		paragraphNode.append(child);
+		quoteNode.insertBefore(paragraphNode);
+		firstNode ||= paragraphNode;
+	}
+	quoteNode.remove();
+	if ($isElementNode(firstNode)) firstNode.select(0, 0);
+}
+function registerBlockBackspace(editor) {
 	return editor.registerCommand(KEY_BACKSPACE_COMMAND, (payload) => {
 		const headingNode = editor.getEditorState().read(() => {
 			const selection = $getSelection();
@@ -4502,6 +5701,22 @@ function registerHeaderBackspace(editor) {
 			});
 			return true;
 		}
+		if (editor.getEditorState().read(() => {
+			const selection = $getSelection();
+			if (!$isRangeSelection(selection) || !selection.isCollapsed()) return false;
+			return $getLeadingQuoteNode(selection);
+		})) {
+			payload.stopImmediatePropagation();
+			payload.preventDefault();
+			payload.stopPropagation();
+			editor.update(() => {
+				const selection = $getSelection();
+				if (!$isRangeSelection(selection) || !selection.isCollapsed()) return;
+				const leadingQuoteNode = $getLeadingQuoteNode(selection);
+				if (leadingQuoteNode) $unwrapQuoteNode(leadingQuoteNode);
+			});
+			return true;
+		}
 		return false;
 	}, COMMAND_PRIORITY_NORMAL);
 }
@@ -4556,6 +5771,7 @@ function registerRichKeydown(editor, kernel, options) {
 				return true;
 			}
 		} else if ($isRangeSelection(selection)) {
+			if ($isSelectionInList(selection)) return false;
 			const possibleNode = $getAdjacentNode(selection.focus, true);
 			const upblock = possibleNode || $getDownUpNode(selection.focus, true);
 			if (!event.shiftKey && $isDecoratorNode(possibleNode)) {
@@ -4625,6 +5841,7 @@ function registerRichKeydown(editor, kernel, options) {
 				event.preventDefault();
 				return true;
 			}
+			if ($isSelectionInList(selection)) return false;
 			const possibleNode = $getAdjacentNode(selection.focus, false);
 			const upblock = possibleNode || $getDownUpNode(selection.focus, false);
 			if (!event.shiftKey && $isDecoratorNode(possibleNode)) {
@@ -4919,7 +6136,18 @@ const CommonPlugin = class extends KernelPlugin {
 			if (this.config?.pasteAsPlainText) return runPasteHandlers(ctx, [handleFilePaste, handlePlainTextPaste]);
 			return false;
 		}, COMMAND_PRIORITY_CRITICAL));
-		this.registerClears(registerRichText(editor), CAN_USE_DOM ? registerDragonSupport(editor) : noop, registerHistory(editor, this.kernel.getHistoryState(), 300), registerHeaderBackspace(editor), registerRichKeydown(editor, this.kernel, { enableHotkey: this.config?.enableHotkey }), registerCommands(editor), registerBreakLineClick(editor), registerCursorNode(editor), registerLastElement(editor), editor.registerCommand(INSERT_LINE_BREAK_COMMAND, () => {
+		let dragonCleanup;
+		const clearDragon = () => {
+			dragonCleanup?.();
+			dragonCleanup = void 0;
+		};
+		this.register(this.kernel.registerRootListener((rootElement) => {
+			clearDragon();
+			if (!rootElement || !CAN_USE_DOM) return;
+			dragonCleanup = registerDragonSupport(editor);
+		}));
+		this.register(clearDragon);
+		this.registerClears(registerRichText(editor), registerProgressiveSelectAll(editor), registerHistory(editor, this.kernel.getHistoryState(), 300), registerBlockBackspace(editor), registerRichKeydown(editor, this.kernel, { enableHotkey: this.config?.enableHotkey }), registerCommands(editor), registerBreakLineClick(editor), registerCursorNode(editor), registerLastElement(editor), editor.registerCommand(INSERT_LINE_BREAK_COMMAND, () => {
 			const selection = $getSelection();
 			if (!$isRangeSelection(selection)) return false;
 			const { inCell, inTable } = $isCursorInTable(selection);
@@ -5793,6 +7021,62 @@ function modeMatch(mode = "") {
 	return LANGUAGES.find((m) => m.value === mode || m.ext?.includes(mode))?.value || "plain";
 }
 //#endregion
+//#region src/plugins/codemirror-block/service/index.ts
+const ICodemirrorEditLockService = genServiceId("CodemirrorEditLockService");
+var CodemirrorEditLockService = class {
+	constructor() {
+		this.providerUnsubscribers = /* @__PURE__ */ new Map();
+		this.providers = /* @__PURE__ */ new Set();
+		this.subscribers = /* @__PURE__ */ new Set();
+	}
+	acquireLock(key, label) {
+		if (this.getRemoteLockOwner(key)) return false;
+		const acquiredProviders = [];
+		for (const provider of this.providers) {
+			if (!provider.acquireLock(key, label)) {
+				acquiredProviders.forEach((acquiredProvider) => acquiredProvider.releaseLock(key));
+				this.notify();
+				return false;
+			}
+			acquiredProviders.push(provider);
+		}
+		this.notify();
+		return true;
+	}
+	getRemoteLockOwner(key) {
+		for (const provider of this.providers) {
+			const owner = provider.getRemoteLockOwner(key);
+			if (owner) return owner;
+		}
+		return null;
+	}
+	registerProvider(provider) {
+		this.providers.add(provider);
+		this.providerUnsubscribers.set(provider, provider.subscribe(() => this.notify()));
+		this.notify();
+		return () => {
+			this.providerUnsubscribers.get(provider)?.();
+			this.providerUnsubscribers.delete(provider);
+			this.providers.delete(provider);
+			this.notify();
+		};
+	}
+	releaseLock(key) {
+		this.providers.forEach((provider) => provider.releaseLock(key));
+		this.notify();
+	}
+	subscribe(listener) {
+		this.subscribers.add(listener);
+		listener();
+		return () => {
+			this.subscribers.delete(listener);
+		};
+	}
+	notify() {
+		this.subscribers.forEach((listener) => listener());
+	}
+};
+//#endregion
 //#region src/plugins/codemirror-block/plugin/index.ts
 const CodemirrorPlugin = class extends KernelPlugin {
 	static {
@@ -5803,6 +7087,7 @@ const CodemirrorPlugin = class extends KernelPlugin {
 		this.kernel = kernel;
 		kernel.registerNodes([CodeMirrorNode]);
 		kernel.registerThemes({ hr: config?.theme || "" });
+		kernel.registerServiceHotReload(ICodemirrorEditLockService, new CodemirrorEditLockService());
 		this.registerDecorator(kernel, "codemirror", (node, editor) => {
 			return config?.decorator ? config.decorator(node, editor) : null;
 		});
@@ -6762,62 +8047,320 @@ const ImagePlugin = class extends KernelPlugin {
 	}
 };
 //#endregion
-//#region src/plugins/link/node/LinkNode.ts
-const logger = createDebugLogger("plugin", "link");
-const SUPPORTED_URL_PROTOCOLS$1 = /* @__PURE__ */ new Set([
-	"http:",
-	"https:",
-	"mailto:",
-	"sms:",
-	"tel:"
-]);
-const HOVER_LINK_COMMAND = createCommand("HOVER_LINK_COMMAND");
-const HOVER_OUT_LINK_COMMAND = createCommand("HOVER_OUT_LINK_COMMAND");
-/** @noInheritDoc */
-var LinkNode = class LinkNode extends ElementNode {
-	static getType() {
-		return "link";
+//#region src/plugins/link/service/i-link-service.ts
+const ILinkService = genServiceId("LinkService");
+const DEFAULT_LABELS = {
+	convertToBlockCard: "Convert to block card",
+	convertToCard: "Convert to card",
+	convertToIframe: "Convert to iframe",
+	convertToLink: "Convert to link",
+	convertToSchema: "Convert to schema"
+};
+var LinkProtocolPolicy = class {
+	constructor() {
+		this.allowedProtocols = /* @__PURE__ */ new Set([
+			"http:",
+			"https:",
+			"mailto:",
+			"sms:",
+			"tel:"
+		]);
 	}
-	static clone(node) {
-		return new LinkNode(node.__url, {
-			rel: node.__rel,
-			target: node.__target,
-			title: node.__title
-		}, node.__key);
+	getAllowedProtocols() {
+		return this.allowedProtocols;
 	}
-	constructor(url = "", attributes = {}, key) {
-		super(key);
-		const { target = null, rel = null, title = null } = attributes;
-		this.__url = url;
-		this.__target = target;
-		this.__rel = rel;
-		this.__title = title;
+	setAllowedProtocols(protocols) {
+		this.allowedProtocols = new Set(protocols.map(normalizeProtocol));
 	}
-	createDOM(config, editor) {
-		logger.debug("🔍 config", config);
-		const element = document.createElement("a");
-		this.updateLinkDOM(null, element, config);
-		addClassNamesToElement(element, config.theme.link);
-		element.addEventListener("mouseenter", (event) => {
-			if (event.target instanceof HTMLElement) {
-				event.target.classList.add("hover");
-				editor.dispatchCommand(HOVER_LINK_COMMAND, {
-					event,
-					linkNode: this
-				});
-			}
-		});
-		element.addEventListener("mouseleave", (event) => {
-			if (event.target instanceof HTMLElement) {
-				event.target.classList.remove("hover");
-				editor.dispatchCommand(HOVER_OUT_LINK_COMMAND, { event });
-			}
-		});
-		return element;
+};
+var LinkRuleRegistry = class {
+	constructor() {
+		this.embedRules = [];
+		this.schemaRules = [];
 	}
-	updateLinkDOM(prevNode, anchor, _config) {
-		if (isHTMLAnchorElement(anchor)) {
-			if (!prevNode || prevNode.__url !== this.__url) anchor.href = this.sanitizeUrl(this.__url);
+	getEmbedRule(url, context) {
+		return this.embedRules.find((rule) => rule.match(url, context)) || null;
+	}
+	getSchemaRule(url, context, parseSchemaUrl) {
+		const schema = context.schema === void 0 ? parseSchemaUrl(url) : context.schema;
+		return this.schemaRules.find((rule) => rule.match(url, {
+			...context,
+			schema
+		})) || null;
+	}
+	getSchemaRuleById(schemaType) {
+		return this.schemaRules.find((rule) => rule.id === schemaType) || null;
+	}
+	setEmbedRules(rules = []) {
+		this.embedRules = rules;
+	}
+	setSchemaRules(rules = []) {
+		this.schemaRules = rules;
+	}
+};
+var LegacySchemaLinkRegistry = class {
+	constructor() {
+		this.protocols = /* @__PURE__ */ new Set();
+	}
+	hasSchemaLinkRenderer(url) {
+		try {
+			const { protocol } = new URL(url);
+			return this.protocols.has(protocol);
+		} catch {
+			return false;
+		}
+	}
+	setSchemaLinkRenderers(renderers = []) {
+		this.protocols = new Set(renderers.map(({ protocol }) => normalizeProtocol(protocol)));
+	}
+};
+var LinkToolbarController = class {
+	constructor() {
+		this.baseEnabled = true;
+		this.labels = DEFAULT_LABELS;
+		this.toolbarActions = [];
+		this.toolbarSuppressions = /* @__PURE__ */ new Set();
+	}
+	get enabled() {
+		return this.baseEnabled && this.toolbarSuppressions.size === 0;
+	}
+	getLabels() {
+		return this.labels;
+	}
+	getToolbarActions(context) {
+		return this.toolbarActions.filter((action) => action.visible?.(context) ?? true);
+	}
+	setLabels(labels) {
+		this.labels = {
+			...DEFAULT_LABELS,
+			...labels
+		};
+	}
+	setToolbarActions(actions = []) {
+		this.toolbarActions = actions;
+	}
+	setEnabled(enable) {
+		const previousEnabled = this.enabled;
+		this.baseEnabled = enable;
+		return previousEnabled !== this.enabled;
+	}
+	suppress(reason = "unknown") {
+		const previousEnabled = this.enabled;
+		const token = Symbol(reason);
+		this.toolbarSuppressions.add(token);
+		return {
+			changed: previousEnabled !== this.enabled,
+			token
+		};
+	}
+	restore(token) {
+		const previousEnabled = this.enabled;
+		if (!this.toolbarSuppressions.delete(token)) return false;
+		return previousEnabled !== this.enabled;
+	}
+};
+var LinkService = class extends EventEmitter {
+	constructor(..._args) {
+		super(..._args);
+		this.cardMetadataLoadingKeys = /* @__PURE__ */ new Set();
+		this.protocolPolicy = new LinkProtocolPolicy();
+		this.legacySchemaLinkRegistry = new LegacySchemaLinkRegistry();
+		this.ruleRegistry = new LinkRuleRegistry();
+		this.toolbarController = new LinkToolbarController();
+		this.toolbarItems = /* @__PURE__ */ new Map();
+	}
+	get enableLinkToolbar() {
+		return this.toolbarController.enabled;
+	}
+	getAllowedProtocols() {
+		return this.protocolPolicy.getAllowedProtocols();
+	}
+	getEmbedRule(url, context) {
+		return this.ruleRegistry.getEmbedRule(url, context);
+	}
+	getLabels() {
+		return this.toolbarController.getLabels();
+	}
+	hasSchemaLinkRenderer(url) {
+		return this.legacySchemaLinkRegistry.hasSchemaLinkRenderer(url);
+	}
+	isCardMetadataLoading(nodeKey) {
+		return this.cardMetadataLoadingKeys.has(nodeKey);
+	}
+	setCardMetadataLoading(nodeKey, loading) {
+		if (!(loading ? !this.cardMetadataLoadingKeys.has(nodeKey) : this.cardMetadataLoadingKeys.has(nodeKey))) return;
+		if (loading) this.cardMetadataLoadingKeys.add(nodeKey);
+		else this.cardMetadataLoadingKeys.delete(nodeKey);
+		this.emit("cardMetadataChange");
+	}
+	getSchemaRule(url, context) {
+		return this.ruleRegistry.getSchemaRule(url, context, (url) => this.parseSchemaUrl(url));
+	}
+	getToolbarActions(context) {
+		return this.toolbarController.getToolbarActions(context);
+	}
+	parseSchemaUrl(url) {
+		try {
+			const parsedUrl = new URL(url);
+			return {
+				hash: parsedUrl.hash,
+				host: parsedUrl.host,
+				params: Object.fromEntries(parsedUrl.searchParams.entries()),
+				pathname: parsedUrl.pathname,
+				protocol: parsedUrl.protocol,
+				raw: url,
+				search: parsedUrl.search
+			};
+		} catch {
+			return null;
+		}
+	}
+	updateConfig(config) {
+		this.setAllowedProtocols([
+			"http:",
+			"https:",
+			"mailto:",
+			"sms:",
+			"tel:",
+			...config?.schemaLinkRenderers?.map(({ protocol }) => protocol) || [],
+			...config?.allowedProtocols || []
+		]);
+		this.setEmbedRules(config?.linkEmbedRules);
+		this.setLabels(config?.labels);
+		this.setSchemaLinkRenderers(config?.schemaLinkRenderers);
+		this.setSchemaRules([...config?.schemaRules || [], ...createLegacySchemaRules(config?.schemaLinkRenderers)]);
+		this.setToolbarActions(config?.toolbarActions);
+	}
+	setAllowedProtocols(protocols) {
+		this.protocolPolicy.setAllowedProtocols(protocols);
+	}
+	setEmbedRules(rules = []) {
+		this.ruleRegistry.setEmbedRules(rules);
+	}
+	setLabels(labels) {
+		this.toolbarController.setLabels(labels);
+	}
+	setSchemaLinkRenderers(renderers = []) {
+		this.legacySchemaLinkRegistry.setSchemaLinkRenderers(renderers);
+	}
+	setSchemaRules(rules = []) {
+		this.ruleRegistry.setSchemaRules(rules);
+	}
+	setToolbarActions(actions = []) {
+		this.toolbarController.setToolbarActions(actions);
+		this.emit("change");
+	}
+	getToolbarItems(context) {
+		return Array.from(this.toolbarItems.values()).filter((item) => item.when ? item.when(context) : true).sort((a, b) => (a.order || 0) - (b.order || 0));
+	}
+	registerToolbarItem(item) {
+		this.toolbarItems.set(item.key, item);
+		this.emit("change");
+		return () => {
+			this.toolbarItems.delete(item.key);
+			this.emit("change");
+		};
+	}
+	setLinkToolbar(enable) {
+		if (this.toolbarController.setEnabled(enable)) this.emit("linkToolbarChange", enable);
+	}
+	suppressLinkToolbar(reason = "unknown") {
+		const { changed, token } = this.toolbarController.suppress(reason);
+		if (changed) this.emit("linkToolbarChange", this.toolbarController.enabled);
+		return token;
+	}
+	restoreLinkToolbar(token) {
+		if (this.toolbarController.restore(token)) this.emit("linkToolbarChange", this.toolbarController.enabled);
+	}
+	subscribe(listener) {
+		this.on("change", listener);
+		return () => {
+			this.off("change", listener);
+		};
+	}
+	subscribeCardMetadata(listener) {
+		this.on("cardMetadataChange", listener);
+		return () => {
+			this.off("cardMetadataChange", listener);
+		};
+	}
+};
+function normalizeProtocol(protocol) {
+	return `${protocol.split(":")[0]}:`;
+}
+function createLegacySchemaRules(renderers = []) {
+	return renderers.map(({ protocol }) => {
+		const normalizedProtocol = normalizeProtocol(protocol);
+		return {
+			id: normalizedProtocol.replace(":", ""),
+			match: (url) => {
+				try {
+					return new URL(url).protocol === normalizedProtocol;
+				} catch {
+					return false;
+				}
+			}
+		};
+	});
+}
+//#endregion
+//#region src/plugins/link/node/LinkNode.ts
+const logger = createDebugLogger("plugin", "link");
+const SUPPORTED_URL_PROTOCOLS$1 = /* @__PURE__ */ new Set([
+	"http:",
+	"https:",
+	"mailto:",
+	"sms:",
+	"tel:"
+]);
+const HOVER_LINK_COMMAND = createCommand("HOVER_LINK_COMMAND");
+const HOVER_OUT_LINK_COMMAND = createCommand("HOVER_OUT_LINK_COMMAND");
+/** @noInheritDoc */
+var LinkNode = class LinkNode extends ElementNode {
+	static getType() {
+		return "link";
+	}
+	static clone(node) {
+		return new LinkNode(node.__url, {
+			rel: node.__rel,
+			target: node.__target,
+			title: node.__title
+		}, node.__key);
+	}
+	constructor(url = "", attributes = {}, key) {
+		super(key);
+		const { target = null, rel = null, title = null } = attributes;
+		this.__url = url;
+		this.__target = target;
+		this.__rel = rel;
+		this.__title = title;
+	}
+	createDOM(config, editor) {
+		logger.debug("🔍 config", config);
+		const element = document.createElement("a");
+		this.updateLinkDOM(null, element, config);
+		addClassNamesToElement(element, config.theme.link);
+		element.addEventListener("mouseenter", (event) => {
+			if (event.target instanceof HTMLElement) {
+				event.target.classList.add("hover");
+				editor.dispatchCommand(HOVER_LINK_COMMAND, {
+					event,
+					node: this
+				});
+			}
+		});
+		element.addEventListener("mouseleave", (event) => {
+			if (event.target instanceof HTMLElement) {
+				event.target.classList.remove("hover");
+				editor.dispatchCommand(HOVER_OUT_LINK_COMMAND, { event });
+			}
+		});
+		return element;
+	}
+	updateLinkDOM(prevNode, anchor, _config) {
+		if (isHTMLAnchorElement(anchor)) {
+			const linkService = getLinkServiceFromConfig(_config);
+			if (!prevNode || prevNode.__url !== this.__url) anchor.href = this.sanitizeUrl(this.__url, linkService?.getAllowedProtocols());
 			for (const attr of [
 				"target",
 				"rel",
@@ -6848,11 +8391,11 @@ var LinkNode = class LinkNode extends ElementNode {
 	updateFromJSON(serializedNode) {
 		return super.updateFromJSON(serializedNode).setURL(serializedNode.url).setRel(serializedNode.rel || null).setTarget(serializedNode.target || null).setTitle(serializedNode.title || null);
 	}
-	sanitizeUrl(url) {
+	sanitizeUrl(url, allowedProtocols = SUPPORTED_URL_PROTOCOLS$1) {
 		url = formatUrl(url);
 		try {
 			const parsedUrl = new URL(formatUrl(url));
-			if (!SUPPORTED_URL_PROTOCOLS$1.has(parsedUrl.protocol)) return "about:blank";
+			if (!allowedProtocols.has(parsedUrl.protocol)) return "about:blank";
 		} catch {
 			return url;
 		}
@@ -6932,7 +8475,13 @@ var LinkNode = class LinkNode extends ElementNode {
 	isWebSiteURI() {
 		return this.__url.startsWith("https://") || this.__url.startsWith("http://");
 	}
+	getDOMSlot(element) {
+		return super.getDOMSlot(element);
+	}
 };
+function getLinkServiceFromConfig(config) {
+	return getKernelFromEditorConfig(config)?.requireService(ILinkService) || null;
+}
 function $convertAnchorElement(domNode) {
 	let node = null;
 	if (isHTMLAnchorElement(domNode)) {
@@ -6960,7 +8509,7 @@ function $createLinkNode(url = "", attributes) {
 * @returns true if node is a LinkNode, false otherwise.
 */
 function $isLinkNode(node) {
-	return node instanceof LinkNode;
+	return node instanceof LinkNode || node?.getType?.() === "link" || node?.getType?.() === "autolink";
 }
 var AutoLinkNode = class AutoLinkNode extends LinkNode {
 	constructor(url = "", attributes = {}, key) {
@@ -7208,6 +8757,7 @@ function formatUrl(url) {
 //#region src/plugins/link/command/index.ts
 const INSERT_LINK_COMMAND = createCommand("INSERT_LINK_COMMAND");
 const UPDATE_LINK_TEXT_COMMAND = createCommand("UPDATE_LINK_TEXT_COMMAND");
+const UNLINK_LINK_COMMAND = createCommand("UNLINK_LINK_COMMAND");
 function registerLinkCommand(editor) {
 	return mergeRegister(editor.registerCommand(INSERT_LINK_COMMAND, (payload) => {
 		const { url, title = url } = payload;
@@ -7217,38 +8767,564 @@ function registerLinkCommand(editor) {
 			linkNode.append(textNode);
 			$insertNodes([linkNode]);
 		});
-		return false;
-	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(UPDATE_LINK_TEXT_COMMAND, (payload) => {
-		const { key, text } = payload;
-		editor.update(() => {
-			const linkNode = $getNodeByKey(key);
-			if (linkNode) {
-				const newLinkNode = $createLinkNode(linkNode.getURL(), { title: text });
-				const textNode = $createTextNode(text);
-				newLinkNode.append(textNode);
-				linkNode?.replace(newLinkNode);
-				newLinkNode.select(1);
+		return false;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(UPDATE_LINK_TEXT_COMMAND, (payload) => {
+		const { key, text } = payload;
+		editor.update(() => {
+			const linkNode = $getNodeByKey(key);
+			if (linkNode) {
+				const newLinkNode = $createLinkNode(linkNode.getURL(), { title: text });
+				const textNode = $createTextNode(text);
+				newLinkNode.append(textNode);
+				linkNode?.replace(newLinkNode);
+				newLinkNode.select(1);
+			}
+		});
+		return false;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(UNLINK_LINK_COMMAND, ({ key }) => {
+		editor.update(() => {
+			const node = $getNodeByKey(key);
+			if (!$isLinkNode(node)) return;
+			let selection = $getSelection();
+			if (!selection || !$isRangeSelection(selection)) {
+				$setSelection($createRangeSelection());
+				selection = $getSelection();
+			}
+			const first = node.getFirstDescendant();
+			const last = node.getLastDescendant();
+			if (selection && $isRangeSelection(selection) && $isTextNode(first) && $isTextNode(last)) {
+				selection.anchor.set(first.getKey(), 0, "text");
+				selection.focus.set(last.getKey(), last.getTextContentSize(), "text");
+				editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+				return;
+			}
+			const children = node.getChildren();
+			for (const child of children) node.insertBefore(child);
+			node.remove();
+		});
+		return true;
+	}, COMMAND_PRIORITY_EDITOR));
+}
+createCommand();
+var LinkCardNode = class LinkCardNode extends DecoratorNode {
+	static getType() {
+		return "link-card";
+	}
+	static clone(node) {
+		return new LinkCardNode(node.__url, node.__title, node.__icon, node.__description, node.__openTarget, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createLinkCardNode({
+			description: serializedNode.description,
+			icon: serializedNode.icon,
+			openTarget: serializedNode.openTarget,
+			title: serializedNode.title,
+			url: serializedNode.url
+		}).updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { a: (node) => {
+			if (node instanceof HTMLAnchorElement && node.dataset.linkCard === "true" && node.dataset.linkCardLayout !== "block") return {
+				conversion: $convertLinkCardElement,
+				priority: 2
+			};
+			return null;
+		} };
+	}
+	constructor(url, title, icon, description, openTarget, key) {
+		super(key);
+		this.__url = url;
+		this.__title = title || url;
+		this.__icon = icon || "";
+		this.__description = description || "";
+		this.__openTarget = openTarget ?? "_blank";
+	}
+	createDOM(config, editor) {
+		const element = document.createElement("span");
+		element.dataset.linkCard = "true";
+		addClassNamesToElement(element, config.theme.linkCard);
+		element.addEventListener("mouseenter", (event) => {
+			if (event.target instanceof HTMLElement) {
+				event.target.classList.add("hover");
+				editor.dispatchCommand(HOVER_LINK_COMMAND, {
+					event,
+					node: this
+				});
+			}
+		});
+		element.addEventListener("mouseleave", (event) => {
+			if (event.target instanceof HTMLElement) {
+				event.target.classList.remove("hover");
+				editor.dispatchCommand(HOVER_OUT_LINK_COMMAND, { event });
+			}
+		});
+		return element;
+	}
+	updateDOM() {
+		return false;
+	}
+	isInline() {
+		return true;
+	}
+	isKeyboardSelectable() {
+		return true;
+	}
+	exportDOM() {
+		const element = document.createElement("a");
+		element.dataset.linkCard = "true";
+		element.dataset.icon = this.getIcon();
+		element.dataset.description = this.getDescription();
+		if (this.getOpenTarget()) element.target = this.getOpenTarget();
+		element.href = this.getURL();
+		element.textContent = this.getTitle();
+		return { element };
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			description: this.getDescription(),
+			icon: this.getIcon(),
+			openTarget: this.getOpenTarget(),
+			title: this.getTitle(),
+			url: this.getURL()
+		};
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode).setURL(serializedNode.url).setTitle(serializedNode.title).setIcon(serializedNode.icon).setDescription(serializedNode.description).setOpenTarget(serializedNode.openTarget ?? "_blank");
+	}
+	getTextContent() {
+		return this.getTitle();
+	}
+	getURL() {
+		return this.getLatest().__url;
+	}
+	setURL(url) {
+		const writable = this.getWritable();
+		writable.__url = url;
+		return writable;
+	}
+	getTitle() {
+		return this.getLatest().__title || this.getURL();
+	}
+	setTitle(title) {
+		const writable = this.getWritable();
+		writable.__title = title || this.getURL();
+		return writable;
+	}
+	getIcon() {
+		return this.getLatest().__icon;
+	}
+	setIcon(icon) {
+		const writable = this.getWritable();
+		writable.__icon = icon || "";
+		return writable;
+	}
+	getDescription() {
+		return this.getLatest().__description;
+	}
+	setDescription(description) {
+		const writable = this.getWritable();
+		writable.__description = description || "";
+		return writable;
+	}
+	getOpenTarget() {
+		return this.getLatest().__openTarget;
+	}
+	setOpenTarget(openTarget) {
+		const writable = this.getWritable();
+		writable.__openTarget = openTarget ?? "_blank";
+		return writable;
+	}
+	decorate(editor) {
+		const decorator = getKernelFromEditor(editor)?.getDecorator(LinkCardNode.getType());
+		if (!decorator) return null;
+		if (typeof decorator === "function") return decorator(this, editor);
+		return decorator.render(this, editor);
+	}
+};
+function $createLinkCardNode(payload) {
+	return $applyNodeReplacement(new LinkCardNode(payload.url, payload.title, payload.icon, payload.description, payload.openTarget));
+}
+function $convertLinkCardElement(domNode) {
+	const element = domNode;
+	return { node: $createLinkCardNode({
+		description: element.dataset.description,
+		icon: element.dataset.icon,
+		openTarget: element.getAttribute("target"),
+		title: element.textContent || element.href,
+		url: element.getAttribute("href") || ""
+	}) };
+}
+function $isLinkCardNode(node) {
+	return node instanceof LinkCardNode || node?.getType?.() === LinkCardNode.getType();
+}
+//#endregion
+//#region src/plugins/link/node/LinkBlockCardNode.ts
+var LinkBlockCardNode = class LinkBlockCardNode extends LinkCardNode {
+	static getType() {
+		return "link-block-card";
+	}
+	static clone(node) {
+		return new LinkBlockCardNode(node.__url, node.__title, node.__icon, node.__description, node.__openTarget, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createLinkBlockCardNode({
+			description: serializedNode.description,
+			icon: serializedNode.icon,
+			openTarget: serializedNode.openTarget,
+			title: serializedNode.title,
+			url: serializedNode.url
+		}).updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { a: (node) => {
+			if (node instanceof HTMLAnchorElement && node.dataset.linkCard === "true" && node.dataset.linkCardLayout === "block") return {
+				conversion: $convertLinkBlockCardElement,
+				priority: 3
+			};
+			return null;
+		} };
+	}
+	constructor(url, title, icon, description, openTarget, key) {
+		super(url, title, icon, description, openTarget, key);
+	}
+	createDOM(config, editor) {
+		const element = super.createDOM(config, editor);
+		element.dataset.linkCardLayout = "block";
+		return element;
+	}
+	exportDOM() {
+		const output = super.exportDOM();
+		if (output.element instanceof HTMLElement) output.element.dataset.linkCardLayout = "block";
+		return output;
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode);
+	}
+	isInline() {
+		return false;
+	}
+};
+function $createLinkBlockCardNode(payload) {
+	return $applyNodeReplacement(new LinkBlockCardNode(payload.url, payload.title, payload.icon, payload.description, payload.openTarget));
+}
+function $convertLinkBlockCardElement(domNode) {
+	const element = domNode;
+	return { node: $createLinkBlockCardNode({
+		description: element.dataset.description,
+		icon: element.dataset.icon,
+		openTarget: element.getAttribute("target"),
+		title: element.textContent || element.href,
+		url: element.getAttribute("href") || ""
+	}) };
+}
+function $isLinkBlockCardNode(node) {
+	return node instanceof LinkBlockCardNode || node?.getType?.() === LinkBlockCardNode.getType();
+}
+//#endregion
+//#region src/plugins/link/node/LinkIframeNode.ts
+var LinkIframeNode = class LinkIframeNode extends DecoratorNode {
+	static getType() {
+		return "link-iframe";
+	}
+	static clone(node) {
+		return new LinkIframeNode(node.__url, node.__src, node.__title, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createLinkIframeNode({
+			src: serializedNode.src,
+			title: serializedNode.title,
+			url: serializedNode.url
+		}).updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { a: (node) => {
+			if (node instanceof HTMLAnchorElement && node.dataset.linkIframe === "true") return {
+				conversion: $convertLinkIframeElement,
+				priority: 2
+			};
+			return null;
+		} };
+	}
+	constructor(url, src, title, key) {
+		super(key);
+		this.__url = url;
+		this.__src = src || url;
+		this.__title = title || url;
+	}
+	createDOM(config, editor) {
+		const element = document.createElement("div");
+		element.dataset.linkIframe = "true";
+		addClassNamesToElement(element, config.theme.linkIframe);
+		element.addEventListener("mouseenter", (event) => {
+			if (event.target instanceof HTMLElement) {
+				event.target.classList.add("hover");
+				editor.dispatchCommand(HOVER_LINK_COMMAND, {
+					event,
+					node: this
+				});
+			}
+		});
+		element.addEventListener("mouseleave", (event) => {
+			if (event.target instanceof HTMLElement) {
+				event.target.classList.remove("hover");
+				editor.dispatchCommand(HOVER_OUT_LINK_COMMAND, { event });
+			}
+		});
+		return element;
+	}
+	updateDOM() {
+		return false;
+	}
+	isInline() {
+		return false;
+	}
+	exportDOM() {
+		const element = document.createElement("a");
+		element.dataset.linkIframe = "true";
+		element.dataset.src = this.getSrc();
+		element.href = this.getURL();
+		element.textContent = this.getTitle();
+		return { element };
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			src: this.getSrc(),
+			title: this.getTitle(),
+			url: this.getURL()
+		};
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode).setURL(serializedNode.url).setSrc(serializedNode.src).setTitle(serializedNode.title);
+	}
+	getTextContent() {
+		return this.getTitle();
+	}
+	getURL() {
+		return this.getLatest().__url;
+	}
+	setURL(url) {
+		const writable = this.getWritable();
+		writable.__url = url;
+		return writable;
+	}
+	getSrc() {
+		return this.getLatest().__src || this.getURL();
+	}
+	setSrc(src) {
+		const writable = this.getWritable();
+		writable.__src = src || this.getURL();
+		return writable;
+	}
+	getTitle() {
+		return this.getLatest().__title || this.getURL();
+	}
+	setTitle(title) {
+		const writable = this.getWritable();
+		writable.__title = title || this.getURL();
+		return writable;
+	}
+	decorate(editor) {
+		const decorator = getKernelFromEditor(editor)?.getDecorator(LinkIframeNode.getType());
+		if (!decorator) return null;
+		if (typeof decorator === "function") return decorator(this, editor);
+		return decorator.render(this, editor);
+	}
+};
+function $createLinkIframeNode(payload) {
+	return $applyNodeReplacement(new LinkIframeNode(payload.url, payload.src, payload.title));
+}
+function $convertLinkIframeElement(domNode) {
+	const element = domNode;
+	return { node: $createLinkIframeNode({
+		src: element.dataset.src,
+		title: element.textContent || element.href,
+		url: element.getAttribute("href") || ""
+	}) };
+}
+function $isLinkIframeNode(node) {
+	return node instanceof LinkIframeNode || node?.getType?.() === LinkIframeNode.getType();
+}
+//#endregion
+//#region src/plugins/link/node/SchemaNode.ts
+var SchemaNode = class SchemaNode extends DecoratorNode {
+	static getType() {
+		return "schema-link";
+	}
+	static clone(node) {
+		return new SchemaNode(node.__url, node.__schemaType, node.__payload, node.__title, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createSchemaNode({
+			payload: serializedNode.payload,
+			schemaType: serializedNode.schemaType,
+			title: serializedNode.title,
+			url: serializedNode.url
+		}).updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { a: (node) => {
+			if (node instanceof HTMLAnchorElement && node.dataset.schemaLink === "true") return {
+				conversion: $convertSchemaElement,
+				priority: 2
+			};
+			return null;
+		} };
+	}
+	constructor(url, schemaType, payload, title, key) {
+		super(key);
+		this.__url = url;
+		this.__schemaType = schemaType || "";
+		this.__payload = payload;
+		this.__title = title || url;
+	}
+	createDOM(config, editor) {
+		const element = document.createElement("div");
+		element.dataset.schemaLink = "true";
+		addClassNamesToElement(element, config.theme.schemaLink);
+		element.addEventListener("mouseenter", (event) => {
+			if (event.target instanceof HTMLElement) {
+				event.target.classList.add("hover");
+				editor.dispatchCommand(HOVER_LINK_COMMAND, {
+					event,
+					node: this
+				});
+			}
+		});
+		element.addEventListener("mouseleave", (event) => {
+			if (event.target instanceof HTMLElement) {
+				event.target.classList.remove("hover");
+				editor.dispatchCommand(HOVER_OUT_LINK_COMMAND, { event });
 			}
 		});
+		return element;
+	}
+	updateDOM() {
 		return false;
-	}, COMMAND_PRIORITY_EDITOR));
-}
-//#endregion
-//#region src/plugins/link/service/i-link-service.ts
-const ILinkService = genServiceId("LinkService");
-var LinkService = class extends EventEmitter {
-	constructor(..._args) {
-		super(..._args);
-		this._enableLinkToolbar = true;
 	}
-	get enableLinkToolbar() {
-		return this._enableLinkToolbar;
+	exportDOM() {
+		const element = document.createElement("a");
+		element.dataset.schemaLink = "true";
+		element.dataset.schemaType = this.getSchemaType();
+		element.dataset.payload = JSON.stringify(this.getPayload() ?? null);
+		element.href = this.getURL();
+		element.textContent = this.getTitle();
+		return { element };
 	}
-	setLinkToolbar(enable) {
-		this._enableLinkToolbar = enable;
-		this.emit("linkToolbarChange", enable);
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			payload: this.getPayload(),
+			schemaType: this.getSchemaType(),
+			title: this.getTitle(),
+			url: this.getURL()
+		};
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode).setURL(serializedNode.url).setSchemaType(serializedNode.schemaType).setPayload(serializedNode.payload).setTitle(serializedNode.title);
+	}
+	getTextContent() {
+		return this.getTitle();
+	}
+	getURL() {
+		return this.getLatest().__url;
+	}
+	setURL(url) {
+		const writable = this.getWritable();
+		writable.__url = url;
+		return writable;
+	}
+	getSchemaType() {
+		return this.getLatest().__schemaType;
+	}
+	setSchemaType(schemaType) {
+		const writable = this.getWritable();
+		writable.__schemaType = schemaType || "";
+		return writable;
+	}
+	getPayload() {
+		return this.getLatest().__payload;
+	}
+	setPayload(payload) {
+		const writable = this.getWritable();
+		writable.__payload = payload;
+		return writable;
+	}
+	getTitle() {
+		return this.getLatest().__title || this.getURL();
+	}
+	setTitle(title) {
+		const writable = this.getWritable();
+		writable.__title = title || this.getURL();
+		return writable;
+	}
+	decorate(editor) {
+		const decorator = getKernelFromEditor(editor)?.getDecorator(SchemaNode.getType());
+		if (!decorator) return null;
+		if (typeof decorator === "function") return decorator(this, editor);
+		return decorator.render(this, editor);
 	}
 };
+function $createSchemaNode(payload) {
+	return $applyNodeReplacement(new SchemaNode(payload.url, payload.schemaType, payload.payload, payload.title));
+}
+function $convertSchemaElement(domNode) {
+	const element = domNode;
+	return { node: $createSchemaNode({
+		payload: parsePayload(element.dataset.payload),
+		schemaType: element.dataset.schemaType,
+		title: element.textContent || element.href,
+		url: element.getAttribute("href") || ""
+	}) };
+}
+function parsePayload(value) {
+	if (!value) return void 0;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+function $isSchemaNode(node) {
+	return node instanceof SchemaNode || node?.getType?.() === SchemaNode.getType();
+}
+//#endregion
+//#region src/plugins/link/normalization/index.ts
+function normalizeSchemaLinkNode(node, editor, linkService) {
+	const url = node.getURL();
+	const title = node.getTitle() || node.getTextContent() || url;
+	const schema = linkService.parseSchemaUrl(url);
+	const rule = linkService.getSchemaRule(url, {
+		editor,
+		schema,
+		text: node.getTextContent(),
+		title
+	});
+	if (!rule) return false;
+	const parsed = rule.parse?.(url, schema);
+	const payload = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? normalizeSchemaPayload(parsed) : { payload: parsed };
+	if (linkService.hasSchemaLinkRenderer(url)) payload.payload = {
+		...payload.payload && typeof payload.payload === "object" ? payload.payload : {},
+		__legacyLink: {
+			rel: node.getRel(),
+			target: node.getTarget(),
+			text: node.getTextContent(),
+			title: node.getTitle()
+		}
+	};
+	node.replace($createSchemaNode({
+		payload: payload.payload,
+		schemaType: payload.schemaType || rule.id,
+		title: payload.title || title,
+		url: payload.url || url
+	}));
+	return true;
+}
+function normalizeSchemaPayload(payload) {
+	if ("payload" in payload || "schemaType" in payload || "title" in payload || "url" in payload) return payload;
+	return { payload };
+}
 //#endregion
 //#region src/plugins/link/utils/index.ts
 const SUPPORTED_URL_PROTOCOLS = /* @__PURE__ */ new Set([
@@ -7377,10 +9453,22 @@ const LinkPlugin = class extends KernelPlugin {
 		super();
 		this.kernel = kernel;
 		this.config = config;
-		this.linkRegex = /^https?:\/\/\S+$/;
+		this.linkRegex = /^[a-z][\d+.a-z-]*:\/\/\S+$/i;
 		this.service = new LinkService();
-		kernel.registerNodes([LinkNode, AutoLinkNode]);
+		kernel.registerNodes([
+			LinkNode,
+			AutoLinkNode,
+			LinkCardNode,
+			LinkBlockCardNode,
+			LinkIframeNode,
+			SchemaNode
+		]);
+		this.service.updateConfig(config);
 		kernel.registerService(ILinkService, this.service);
+		this.registerDecorator(kernel, LinkCardNode.getType(), (node, editor) => config?.decoratorCard ? config.decoratorCard(node, editor) : null);
+		this.registerDecorator(kernel, LinkBlockCardNode.getType(), (node, editor) => config?.decoratorCard ? config.decoratorCard(node, editor) : null);
+		this.registerDecorator(kernel, LinkIframeNode.getType(), (node, editor) => config?.decoratorIframe ? config.decoratorIframe(node, editor) : null);
+		this.registerDecorator(kernel, SchemaNode.getType(), (node, editor) => config?.decoratorSchema ? config.decoratorSchema(node, editor) : null);
 		if (config?.theme) kernel.registerThemes(config.theme);
 		if (config?.linkRegex) this.linkRegex = config.linkRegex;
 	}
@@ -7404,6 +9492,9 @@ const LinkPlugin = class extends KernelPlugin {
 			}
 			return false;
 		}, COMMAND_PRIORITY_NORMAL));
+		if (this.config?.normalizeSchemaLinks !== false) this.register(editor.registerNodeTransform(LinkNode, (node) => {
+			normalizeSchemaLinkNode(node, editor, this.service);
+		}));
 		this.registerMarkdown();
 		this.registerLiteXml();
 	}
@@ -7428,6 +9519,74 @@ const LinkPlugin = class extends KernelPlugin {
 				version: 1
 			})];
 		});
+		litexmlService.registerXMLWriter(LinkCardNode.getType(), (node, ctx) => {
+			if (!$isLinkCardNode(node)) return false;
+			return ctx.createXmlNode("link-card", {
+				description: node.getDescription(),
+				href: node.getURL(),
+				icon: node.getIcon(),
+				openTarget: node.getOpenTarget() || "_blank",
+				title: node.getTitle()
+			});
+		});
+		litexmlService.registerXMLWriter(LinkBlockCardNode.getType(), (node, ctx) => {
+			if (!$isLinkBlockCardNode(node)) return false;
+			return ctx.createXmlNode("link-card", {
+				description: node.getDescription(),
+				href: node.getURL(),
+				icon: node.getIcon(),
+				layout: "block",
+				openTarget: node.getOpenTarget() || "_blank",
+				title: node.getTitle()
+			});
+		});
+		litexmlService.registerXMLReader("link-card", (xmlNode) => {
+			return [INodeHelper.createTypeNode(xmlNode.getAttribute("layout") === "block" ? LinkBlockCardNode.getType() : LinkCardNode.getType(), {
+				description: xmlNode.getAttribute("description") || "",
+				icon: xmlNode.getAttribute("icon") || "",
+				openTarget: xmlNode.getAttribute("openTarget") || "_blank",
+				title: xmlNode.getAttribute("title") || xmlNode.getAttribute("href") || "",
+				type: xmlNode.getAttribute("layout") === "block" ? LinkBlockCardNode.getType() : LinkCardNode.getType(),
+				url: xmlNode.getAttribute("href") || "",
+				version: 1
+			})];
+		});
+		litexmlService.registerXMLWriter(LinkIframeNode.getType(), (node, ctx) => {
+			if (!$isLinkIframeNode(node)) return false;
+			return ctx.createXmlNode("link-iframe", {
+				href: node.getURL(),
+				src: node.getSrc(),
+				title: node.getTitle()
+			});
+		});
+		litexmlService.registerXMLReader("link-iframe", (xmlNode) => {
+			return [INodeHelper.createTypeNode(LinkIframeNode.getType(), {
+				src: xmlNode.getAttribute("src") || xmlNode.getAttribute("href") || "",
+				title: xmlNode.getAttribute("title") || xmlNode.getAttribute("href") || "",
+				type: LinkIframeNode.getType(),
+				url: xmlNode.getAttribute("href") || "",
+				version: 1
+			})];
+		});
+		litexmlService.registerXMLWriter(SchemaNode.getType(), (node, ctx) => {
+			if (!$isSchemaNode(node)) return false;
+			return ctx.createXmlNode("schema-link", {
+				href: node.getURL(),
+				payload: JSON.stringify(node.getPayload() ?? null),
+				schemaType: node.getSchemaType(),
+				title: node.getTitle()
+			});
+		});
+		litexmlService.registerXMLReader("schema-link", (xmlNode) => {
+			return [INodeHelper.createTypeNode(SchemaNode.getType(), {
+				payload: parseJsonAttribute(xmlNode.getAttribute("payload")),
+				schemaType: xmlNode.getAttribute("schemaType") || "",
+				title: xmlNode.getAttribute("title") || xmlNode.getAttribute("href") || "",
+				type: SchemaNode.getType(),
+				url: xmlNode.getAttribute("href") || "",
+				version: 1
+			})];
+		});
 	}
 	registerMarkdown() {
 		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownShortCut({
@@ -7447,6 +9606,30 @@ const LinkPlugin = class extends KernelPlugin {
 		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(LinkNode.getType(), (ctx, node) => {
 			if ($isLinkNode(node)) ctx.wrap("[", `](${node.getURL()})`);
 		});
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(LinkCardNode.getType(), (ctx, node) => {
+			if ($isLinkCardNode(node)) {
+				ctx.appendLine(`[${node.getTitle()}](${node.getURL()})\n`);
+				return true;
+			}
+		});
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(LinkBlockCardNode.getType(), (ctx, node) => {
+			if ($isLinkBlockCardNode(node)) {
+				ctx.appendLine(`[${node.getTitle()}](${node.getURL()})\n`);
+				return true;
+			}
+		});
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(LinkIframeNode.getType(), (ctx, node) => {
+			if ($isLinkIframeNode(node)) {
+				ctx.appendLine(`[${node.getTitle()}](${node.getURL()})\n`);
+				return true;
+			}
+		});
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(SchemaNode.getType(), (ctx, node) => {
+			if ($isSchemaNode(node)) {
+				ctx.appendLine(`[${node.getTitle()}](${node.getURL()})\n`);
+				return true;
+			}
+		});
 		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownReader("link", (node, children) => {
 			return [INodeHelper.createElementNode("link", {
 				children,
@@ -7461,6 +9644,14 @@ const LinkPlugin = class extends KernelPlugin {
 		});
 	}
 };
+function parseJsonAttribute(value) {
+	if (!value) return void 0;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
 //#endregion
 //#region src/utils/cx.ts
 const cx = (...classNames) => classNames.filter(Boolean).join(" ");
@@ -7819,7 +10010,11 @@ const ListPlugin = class extends KernelPlugin {
 			type: "element"
 		});
 		markdownService.registerMarkdownWriter(ListNode.getType(), (ctx, node) => {
-			if ($isListNode(node)) ctx.wrap("", "\n");
+			if ($isListNode(node)) {
+				const parent = node.getParent();
+				const needsLeadingNewline = $isListItemNode(parent) && node.getPreviousSibling() !== null;
+				ctx.wrap(needsLeadingNewline ? "\n" : "", "\n");
+			}
 		});
 		const getLevel = (node) => {
 			if (!node) return 0;
@@ -7850,7 +10045,10 @@ const ListPlugin = class extends KernelPlugin {
 			let start = node.start || 1;
 			return INodeHelper.createElementNode("list", {
 				children: children.map((v) => {
-					if (v.type === "listitem") v.value = start++;
+					if (v.type === "listitem") {
+						v.value = start;
+						if (v.children?.[0]?.type !== "list") start++;
+					}
 					return v;
 				}),
 				direction: "ltr",
@@ -8922,10 +11120,88 @@ var TableControllerMenuService = class {
 	}
 };
 //#endregion
+//#region src/plugins/table/plugin/single-cell-paste.ts
+const LEXICAL_CLIPBOARD_TYPE = "application/x-lexical-editor";
+const countNodesByType = (node, type) => {
+	return (node.type === type ? 1 : 0) + (Array.isArray(node.children) ? node.children.reduce((count, child) => count + countNodesByType(child, type), 0) : 0);
+};
+const parseLexicalTableClipboard = (serializedClipboard) => {
+	if (!serializedClipboard) return void 0;
+	try {
+		const clipboard = JSON.parse(serializedClipboard);
+		if (!Array.isArray(clipboard.nodes) || clipboard.nodes.length !== 1) return { isSingleCell: false };
+		const [rootNode] = clipboard.nodes;
+		if (rootNode?.type !== "table") return { isSingleCell: false };
+		const cells = [];
+		const collectCells = (node) => {
+			if (node.type === "tablecell") cells.push(node);
+			node.children?.forEach(collectCells);
+		};
+		collectCells(rootNode);
+		const isSingleCell = countNodesByType(rootNode, "table") === 1 && cells.length === 1;
+		return {
+			cell: isSingleCell ? cells[0] : void 0,
+			isSingleCell
+		};
+	} catch {
+		return;
+	}
+};
+const getSerializedNodeText = (node) => {
+	if (node.type === "text") return node.text || "";
+	if (node.type === "linebreak") return "\n";
+	if (node.type === "tab") return "	";
+	return node.children?.map(getSerializedNodeText).join("") || "";
+};
+const getSerializedCellText = (cell) => {
+	return cell.children?.map(getSerializedNodeText).join("\n") || "";
+};
+const getSingleCellHTMLText = (html) => {
+	if (!isSingleCellHTMLTable(html) || typeof DOMParser === "undefined") return void 0;
+	const cell = new DOMParser().parseFromString(html, "text/html").body.querySelector("td, th");
+	if (!cell) return void 0;
+	cell.querySelectorAll("br").forEach((node) => node.replaceWith("\n"));
+	return Array.from(cell.children).map((node) => node.textContent || "").join("\n") || cell.textContent || "";
+};
+const isSingleCellHTMLTable = (html) => {
+	if (!html || typeof DOMParser === "undefined") return false;
+	const document = new DOMParser().parseFromString(html, "text/html");
+	const tables = document.body.querySelectorAll("table");
+	if (tables.length !== 1 || tables[0].querySelectorAll("td, th").length !== 1) return false;
+	const remainder = document.body.cloneNode(true);
+	remainder.querySelector("table")?.remove();
+	remainder.querySelectorAll("link, meta, script, style").forEach((node) => node.remove());
+	return !remainder.querySelector("audio, canvas, iframe, img, object, svg, video") && remainder.textContent?.trim() === "";
+};
+const isSingleCellTableClipboard = (clipboardData) => {
+	const lexicalResult = parseLexicalTableClipboard(clipboardData.getData(LEXICAL_CLIPBOARD_TYPE));
+	if (lexicalResult !== void 0) return lexicalResult.isSingleCell;
+	return isSingleCellHTMLTable(clipboardData.getData("text/html"));
+};
+const getSingleCellPlainText = (clipboardData) => {
+	const lexicalResult = parseLexicalTableClipboard(clipboardData.getData(LEXICAL_CLIPBOARD_TYPE));
+	if (lexicalResult?.cell) return getSerializedCellText(lexicalResult.cell);
+	const htmlText = getSingleCellHTMLText(clipboardData.getData("text/html"));
+	if (htmlText !== void 0) return htmlText;
+	return clipboardData.getData("text/plain").replace(/(?:\r\n|\n)$/, "");
+};
+const handleSingleCellTablePaste = (editor, event) => {
+	if (!("clipboardData" in event)) return false;
+	const clipboardData = event.clipboardData;
+	if (!clipboardData || !isSingleCellTableClipboard(clipboardData)) return false;
+	event.preventDefault();
+	editor.dispatchCommand(CONTROLLED_TEXT_INSERTION_COMMAND, getSingleCellPlainText(clipboardData));
+	return true;
+};
+const registerSingleCellTablePaste = (editor) => {
+	return editor.registerCommand(PASTE_COMMAND, (event) => handleSingleCellTablePaste(editor, event), COMMAND_PRIORITY_HIGH);
+};
+//#endregion
 //#region src/plugins/table/plugin/index.ts
 const tableCellProcessor = (before, content, after) => {
 	return before + content.replace(/\n+$/, "").replaceAll(/\n+/g, "<br />") + after;
 };
+const isRemovedTableRowDiff = (node) => node.getType() === "table-row-diff" && "getDiffType" in node && typeof node.getDiffType === "function" && node.getDiffType() === "remove";
 function isHeadlessEditor(editor) {
 	return editor._headless === true;
 }
@@ -8974,6 +11250,7 @@ const TablePlugin = class extends KernelPlugin {
 	}
 	onInit(editor) {
 		this.register(registerTableCellUnmergeTransform(editor));
+		this.register(registerSingleCellTablePaste(editor));
 		if (!isHeadlessEditor(editor)) {
 			setScrollableTablesActive(editor, true);
 			this.register(registerTablePlugin(editor));
@@ -9220,7 +11497,7 @@ const TablePlugin = class extends KernelPlugin {
 		markdownService.registerMarkdownWriter(TableRowNode.getType(), (ctx, node) => {
 			const parent = node.getParent();
 			if (!$isTableNode(parent)) return;
-			if (!node.getPreviousSibling()) ctx.wrap("", `\n${parent.getColWidths()?.map(() => {
+			if (!node.getPreviousSiblings().some((sibling) => !isRemovedTableRowDiff(sibling))) ctx.wrap("", `\n${parent.getColWidths()?.map(() => {
 				return "|:--";
 			}).join("")}|\n`);
 			else ctx.wrap("", "\n");
@@ -9267,6 +11544,207 @@ const TablePlugin = class extends KernelPlugin {
 	}
 };
 //#endregion
+//#region src/plugins/collapsible/node/CollapsibleNode.ts
+const CONTENT_SELECTOR = "[data-collapsible-content=\"true\"]";
+const TOGGLE_SELECTOR = "[data-collapsible-toggle=\"true\"]";
+var CollapsibleNode = class CollapsibleNode extends ElementNode {
+	static getType() {
+		return "collapsible";
+	}
+	static clone(node) {
+		return new CollapsibleNode(node.__title, node.__collapsed, node.__key);
+	}
+	static importDOM() {
+		return { details: () => ({
+			conversion: $convertDetailsElement,
+			priority: 1
+		}) };
+	}
+	static importJSON(serializedNode) {
+		const node = $createCollapsibleNode(serializedNode.title || "Details").updateFromJSON(serializedNode);
+		if (shouldPrependTitle(serializedNode)) {
+			const titleParagraph = $createTitleParagraph(serializedNode.title || "Details");
+			const firstChild = node.getFirstChild();
+			if (firstChild) firstChild.insertBefore(titleParagraph);
+			else node.append(titleParagraph);
+		}
+		return node;
+	}
+	constructor(title = "Details", collapsed = false, key) {
+		super(key);
+		this.__title = title;
+		this.__collapsed = collapsed;
+	}
+	createDOM(config, editor) {
+		const element = document.createElement("section");
+		addClassNamesToElement(element, config.theme.collapsible);
+		element.dataset.collapsible = "true";
+		element.dataset.collapsibleCollapsed = String(this.__collapsed);
+		const toggle = document.createElement("button");
+		toggle.type = "button";
+		toggle.contentEditable = "false";
+		toggle.dataset.collapsibleToggle = "true";
+		toggle.setAttribute("aria-expanded", String(!this.__collapsed));
+		toggle.setAttribute("aria-label", this.__collapsed ? "Expand collapsible block" : "Collapse collapsible block");
+		toggle.addEventListener("click", () => {
+			editor.update(() => {
+				const latest = this.getLatest();
+				if ($isCollapsibleNode(latest)) latest.setCollapsed(!latest.isCollapsed());
+			});
+		});
+		const content = document.createElement("div");
+		content.dataset.collapsibleContent = "true";
+		element.append(toggle, content);
+		return element;
+	}
+	updateDOM(prevNode, dom) {
+		const toggle = dom.querySelector(TOGGLE_SELECTOR);
+		dom.dataset.collapsibleCollapsed = String(this.__collapsed);
+		if (toggle && prevNode.__collapsed !== this.__collapsed) {
+			toggle.setAttribute("aria-expanded", String(!this.__collapsed));
+			toggle.setAttribute("aria-label", this.__collapsed ? "Expand collapsible block" : "Collapse collapsible block");
+		}
+		return false;
+	}
+	exportDOM() {
+		const element = document.createElement("details");
+		if (!this.__collapsed) element.setAttribute("open", "");
+		const summary = document.createElement("summary");
+		summary.textContent = this.getTitle();
+		element.append(summary);
+		return { element };
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			collapsed: this.isCollapsed(),
+			title: this.getTitle()
+		};
+	}
+	getDOMSlot(element) {
+		const content = element.querySelector(CONTENT_SELECTOR);
+		if (content instanceof HTMLElement) return super.getDOMSlot(element).withElement(content);
+		return super.getDOMSlot(element);
+	}
+	getTitle() {
+		const latest = this.getLatest();
+		const firstChild = latest.getFirstChild();
+		return firstChild ? firstChild.getTextContent().trim() : latest.__title;
+	}
+	isCollapsed() {
+		return this.getLatest().__collapsed;
+	}
+	isShadowRoot() {
+		return true;
+	}
+	setCollapsed(collapsed) {
+		const writable = this.getWritable();
+		writable.__collapsed = collapsed;
+		return writable;
+	}
+	setTitle(title) {
+		const writable = this.getWritable();
+		writable.__title = title;
+		return writable;
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode).setTitle(serializedNode.title || "Details").setCollapsed(Boolean(serializedNode.collapsed));
+	}
+};
+function $createCollapsibleNode(title = "Details", collapsed = false) {
+	return $applyNodeReplacement(new CollapsibleNode(title, collapsed));
+}
+function $isCollapsibleNode(node) {
+	return node instanceof CollapsibleNode;
+}
+function $convertDetailsElement(domNode) {
+	if (!(domNode instanceof HTMLDetailsElement)) return { node: null };
+	return { node: $createCollapsibleNode(domNode.querySelector("summary")?.textContent?.trim() || "Details", !domNode.open) };
+}
+function $createTitleParagraph(title) {
+	const paragraph = $createParagraphNode();
+	paragraph.append($createTextNode(title));
+	return paragraph;
+}
+function getSerializedText(node) {
+	if (!node || typeof node !== "object") return "";
+	if ("text" in node && typeof node.text === "string") return node.text;
+	if ("children" in node && Array.isArray(node.children)) return node.children.map((child) => getSerializedText(child)).join("");
+	return "";
+}
+function shouldPrependTitle(serializedNode) {
+	const title = serializedNode.title?.trim();
+	if (!title) return false;
+	const firstChild = (Array.isArray(serializedNode.children) ? serializedNode.children : [])[0];
+	return getSerializedText(firstChild).trim() !== title;
+}
+//#endregion
+//#region src/headless/collapsible-plugin.ts
+const HeadlessCollapsiblePlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "HeadlessCollapsiblePlugin";
+	}
+	constructor(kernel) {
+		super();
+		this.kernel = kernel;
+		kernel.registerNodes([CollapsibleNode]);
+	}
+	onInit(_editor) {
+		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
+		markdownService?.registerMarkdownWriter(CollapsibleNode.getType(), (ctx, node) => {
+			if (!$isCollapsibleNode(node)) return false;
+			ctx.appendLine(`<details${node.isCollapsed() ? "" : " open"}>\n`);
+			ctx.appendLine(`<summary>${escapeHtml(node.getTitle())}</summary>\n\n`);
+			node.getChildren().slice(1).forEach((child) => ctx.processChild(ctx, child));
+			ctx.appendLine("\n</details>\n");
+			return true;
+		});
+		markdownService?.registerMarkdownReader("html", (node, children) => {
+			const tag = getHtmlTagName(node.value);
+			if (tag === "summary") return INodeHelper.createTypeNode("__collapsible_summary", { text: getNodeText(children) });
+			if (tag !== "details") return false;
+			const summaryNode = children.find((child) => child.type === "__collapsible_summary");
+			const contentChildren = children.filter((child) => child.type !== "__collapsible_summary");
+			const title = summaryNode && "text" in summaryNode && typeof summaryNode.text === "string" ? summaryNode.text : extractSummaryTitle(node.value) || "Details";
+			return INodeHelper.createElementNode(CollapsibleNode.getType(), {
+				children: ensureTitleChildren(contentChildren, title),
+				collapsed: !/\sopen(?:\s|>|$)/i.test(node.value),
+				title
+			});
+		});
+		const litexmlService = this.kernel.requireService(ILitexmlService);
+		litexmlService?.registerXMLWriter(CollapsibleNode.getType(), (node, ctx) => {
+			if (!$isCollapsibleNode(node)) return false;
+			return ctx.createXmlNode("collapsible", {
+				collapsed: String(node.isCollapsed()),
+				title: node.getTitle()
+			});
+		});
+		litexmlService?.registerXMLReader("collapsible", (xmlNode, children) => {
+			const title = xmlNode.getAttribute("title") || "Details";
+			return INodeHelper.createElementNode(CollapsibleNode.getType(), {
+				children: ensureTitleChildren(children, title),
+				collapsed: xmlNode.getAttribute("collapsed") === "true",
+				title
+			});
+		});
+	}
+};
+const getHtmlTagName = (value) => value.match(/^<\/?\s*([\da-z-]+)/i)?.[1]?.toLowerCase() || "";
+const escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+const extractSummaryTitle = (value) => value.match(/<summary\b[^>]*>([\S\s]*?)<\/summary>/i)?.[1]?.trim() || "";
+const getNodeText = (children) => children.map((child) => {
+	if (!child || typeof child !== "object") return "";
+	if ("text" in child && typeof child.text === "string") return child.text;
+	if ("children" in child && Array.isArray(child.children)) return getNodeText(child.children);
+	return "";
+}).join("");
+const ensureTitleChildren = (children, title) => {
+	const trimmedTitle = title.trim();
+	if (!trimmedTitle || getNodeText(children.slice(0, 1)).trim() === trimmedTitle) return children;
+	return [INodeHelper.createParagraph({ children: [INodeHelper.createTextNode(title)] }), ...children];
+};
+//#endregion
 //#region src/headless/extract-media-from-editor-state.ts
 const IMAGE_TYPES = /* @__PURE__ */ new Set(["image", "block-image"]);
 const FILE_TYPE = "file";
@@ -9416,6 +11894,7 @@ const DEFAULT_HEADLESS_EDITOR_PLUGINS = [
 	HRPlugin,
 	ListPlugin,
 	TablePlugin,
+	HeadlessCollapsiblePlugin,
 	LitexmlPlugin
 ];
 var HeadlessEditor = class {