@lobehub/editor 4.29.0 → 4.29.2

package/es/headless.js

@@ -1,10 +1,13 @@
-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 { getNodeIdentityPolicyRevision, registerNodeIdentityPolicy, subscribeNodeIdentityPolicy } from "./plugins/common/node/node-identity-policy.js";
+import { $clearNodeId, $copyNodeProperties, $ensureUniqueNodeIds, $findNodeById, $getActiveNodeIdKeys, $getNodeById, $getNodeId, $normalizeNodeIds, $setNodeId, isValidContentNodeId, migrateSerializedNodeIds } from "./plugins/common/node/node-id.js";
+import { INodeIdentityService } from "./plugins/common/service/i-node-identity-service.js";
+import { LITEXML_APPLY_COMMAND, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_MODIFY_WITH_RESULTS_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, $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, SELECT_ALL_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, RootNode, SELECTION_CHANGE_COMMAND, SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, SELECT_ALL_COMMAND, TEXT_TYPE_TO_FORMAT, TextNode, UNDO_COMMAND, createCommand, createEditor, getNearestEditorFromDOMNode, isHTMLElement, isModifierMatch, 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";
@@ -250,7 +253,7 @@ function $isCursorInQuote(selection) {
 function exportNodeToJSON$1(node) {
 	const serializedNode = node.exportJSON();
 	const nodeClass = node.constructor;
-	serializedNode.id = node.getKey();
+	serializedNode.id = $getNodeId(node);
 	if (serializedNode.type !== nodeClass.getType()) throw new Error(`LexicalNode: Node ${nodeClass.name} does not match the serialized type. Check if .exportJSON() is implemented and it is returning the correct type.`);
 	if ($isElementNode(node)) {
 		const serializedChildren = serializedNode.children;
@@ -593,7 +596,7 @@ const isHotkeyMatch = (event, hotkey) => {
 };
 //#endregion
 //#region src/utils/hotkey/registerHotkey.ts
-const logger$9 = createDebugLogger("hotkey");
+const logger$10 = createDebugLogger("hotkey");
 const registerHotkey = (hotkey, callback, options = {}) => {
 	return (e) => {
 		if (!isHotkeyMatch(e, hotkey.keys)) return false;
@@ -605,7 +608,7 @@ const registerHotkey = (hotkey, callback, options = {}) => {
 			...keys,
 			scopes: hotkey.scopes
 		});
-		logger$9.debug(`⌨️ Hotkey matched: ${hotkey.id} [${hotkey.keys}]`, hotkey);
+		logger$10.debug(`⌨️ Hotkey matched: ${hotkey.id} [${hotkey.keys}]`, hotkey);
 		return true;
 	};
 };
@@ -1492,7 +1495,7 @@ function registerCommands(editor) {
 }
 //#endregion
 //#region src/plugins/common/node/cursor.ts
-const logger$8 = createDebugLogger("common", "cursor");
+const logger$9 = createDebugLogger("common", "cursor");
 var CardLikeElementNode = class extends ElementNode {
 	isCardLike() {
 		return true;
@@ -1531,7 +1534,7 @@ function registerCursorNode(editor) {
 			const needAddCursor = [];
 			for (const [kClass, nodeMaps] of mutatedNodes) if (DecoratorNode.prototype.isPrototypeOf(kClass.prototype)) for (const [key, mutation] of nodeMaps) {
 				const node = $getNodeByKey(key);
-				logger$8.debug("🎭 DecoratorNode mutated:", node?.getType(), mutation, node);
+				logger$9.debug("🎭 DecoratorNode mutated:", node?.getType(), mutation, node);
 				if (mutation === "created" && node?.isInline() && node.getNextSibling() === null) needAddCursor.push(node);
 			}
 			if (needAddCursor.length > 0) editor.update(() => {
@@ -1633,7 +1636,7 @@ function registerCursorNode(editor) {
 			$setSelection(sel);
 			return true;
 		} catch (error) {
-			logger$8.error("❌ Cursor selection error:", error);
+			logger$9.error("❌ Cursor selection error:", error);
 		}
 		else if ($isCursorNode(focusNode)) try {
 			const { key: anchorKey, offset: anchorOffset, type: anchorType } = selection.anchor;
@@ -1644,7 +1647,7 @@ function registerCursorNode(editor) {
 			$setSelection(sel);
 			return true;
 		} catch (error) {
-			logger$8.error("❌ Cursor navigation error:", error);
+			logger$9.error("❌ Cursor navigation error:", error);
 		}
 		return false;
 	}, COMMAND_PRIORITY_HIGH), editor.registerCommand(KEY_ARROW_RIGHT_COMMAND, (event) => {
@@ -1675,6 +1678,174 @@ function registerCursorNode(editor) {
 	}, COMMAND_PRIORITY_HIGH));
 }
 //#endregion
+//#region src/plugins/common/service/node-identity-service.ts
+const logger$8 = createDebugLogger("service", "node-identity");
+/** Implementation owned by CommonPlugin; external callers use INodeIdentityService. */
+var NodeIdentityService = class {
+	constructor() {
+		this.editor = null;
+		this.indexes = /* @__PURE__ */ new WeakMap();
+		this.listeners = /* @__PURE__ */ new Set();
+		this.bindingToken = null;
+		this.unregisterBinding = null;
+	}
+	bindEditor(editor) {
+		this.unregisterBinding?.();
+		const bindingToken = {};
+		this.bindingToken = bindingToken;
+		this.indexes = /* @__PURE__ */ new WeakMap();
+		this.editor = editor;
+		const unregisterUpdate = editor.registerUpdateListener(({ editorState, prevEditorState }) => {
+			if (editorState !== prevEditorState) this.notify();
+		});
+		const unregisterPolicy = subscribeNodeIdentityPolicy(editor, () => this.notify());
+		let active = true;
+		const unregister = () => {
+			if (!active) return;
+			active = false;
+			unregisterUpdate();
+			unregisterPolicy();
+		};
+		this.unregisterBinding = unregister;
+		return () => {
+			unregister();
+			if (this.bindingToken !== bindingToken) return;
+			this.bindingToken = null;
+			this.unregisterBinding = null;
+			this.editor = null;
+			this.indexes = /* @__PURE__ */ new WeakMap();
+			this.listeners.clear();
+		};
+	}
+	getNodeById(nodeId) {
+		if (typeof nodeId !== "string" || !nodeId.trim()) return null;
+		const editor = this.editor;
+		if (!editor) return null;
+		const editorState = editor.getEditorState();
+		const revision = getNodeIdentityPolicyRevision(editor);
+		let index = this.indexes.get(editorState);
+		if (!index || index.revision !== revision) {
+			index = {
+				keys: editorState.read(() => $getActiveNodeIdKeys(), { editor }),
+				revision
+			};
+			this.indexes.set(editorState, index);
+		}
+		const key = index.keys.get(nodeId);
+		if (!key) return null;
+		return editorState.read(() => {
+			const node = $getNodeByKey(key);
+			const id = node && $getNodeId(node);
+			return node && id === nodeId ? Object.freeze({
+				id,
+				textContent: node.getTextContent(),
+				type: node.getType()
+			}) : null;
+		}, { editor });
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	notify() {
+		const listeners = Array.from(this.listeners);
+		for (const listener of listeners) try {
+			listener();
+		} catch (error) {
+			logger$8.error("Node identity subscriber failed:", error);
+		}
+	}
+};
+//#endregion
+//#region src/plugins/litexml/node/identity-policy.ts
+const afterRepresentation = Object.freeze({ childIndex: 1 });
+/** Shared active-view rule for live Lexical nodes and serialized preflight trees. */
+function getLiteXmlIdentityProjection(node) {
+	if (node.type === "root" || node.type === "diff-content") return "container";
+	if (node.type === "diff") {
+		if (node.diffType === "remove" || node.diffType === "listItemRemove") return "hidden";
+		if (node.diffType === "modify" || node.diffType === "listItemModify") return afterRepresentation;
+		return "container";
+	}
+	if ((node.type === "table-cell-diff" || node.type === "table-row-diff") && node.diffType === "remove") return "hidden";
+	if (node.type === "listitem" && node.firstChildType === "diff" && node.firstChildDiffType === "listItemRemove") return "hidden";
+	return "content";
+}
+/** Review containers and the document root are physical structure, not addressable content. */
+function isLiteXmlIdentityNode(type) {
+	return type !== "root" && type !== "diff" && type !== "diff-content";
+}
+function getDiffType(node) {
+	if (!node) return void 0;
+	if ("diffType" in node && typeof node.diffType === "string") return node.diffType;
+	if ("getDiffType" in node && typeof node.getDiffType === "function") return node.getDiffType();
+}
+function getLiveProjection(node) {
+	const type = node.getType();
+	if (type === "root" || type === "diff-content") return "container";
+	if (type !== "diff" && type !== "table-cell-diff" && type !== "table-row-diff" && type !== "listitem") return "content";
+	const firstChild = $isElementNode(node) ? node.getFirstChild() : null;
+	return getLiteXmlIdentityProjection({
+		diffType: getDiffType(node),
+		firstChildDiffType: getDiffType(firstChild),
+		firstChildType: firstChild?.getType(),
+		type
+	});
+}
+function getTableReviewSide(node) {
+	const type = node.getType();
+	if (type !== "table-cell-diff" && type !== "table-row-diff") return null;
+	if (!("getChangeId" in node) || typeof node.getChangeId !== "function") return null;
+	const changeId = node.getChangeId();
+	const side = getDiffType(node);
+	return changeId && side ? {
+		group: `${type}:${changeId}`,
+		side
+	} : null;
+}
+function getReviewSide(node) {
+	const selfSide = getTableReviewSide(node);
+	if (selfSide) return selfSide;
+	let branch = node;
+	for (let parent = node.getParent(); parent; branch = parent, parent = parent.getParent()) {
+		const parentDiffType = getDiffType(parent);
+		if (parent.getType() === "diff") {
+			if (parentDiffType === "modify") {
+				if (branch.getType() === "diff-content" && "side" in branch) return {
+					group: `diff:${parent.getKey()}`,
+					side: String(branch.side)
+				};
+				const branchIndex = parent.getChildren().indexOf(branch);
+				if (branchIndex >= 0 && branchIndex < 2) return {
+					group: `diff:${parent.getKey()}`,
+					side: branchIndex === 0 ? "before" : "after"
+				};
+			}
+			if (parentDiffType === "listItemModify") {
+				const branchIndex = parent.getChildren().indexOf(branch);
+				if (branchIndex >= 0 && branchIndex < 2) return {
+					group: `diff:${parent.getKey()}`,
+					side: branchIndex === 0 ? "before" : "after"
+				};
+			}
+		}
+		const tableSide = getTableReviewSide(parent);
+		if (tableSide) return tableSide;
+	}
+	return null;
+}
+const liteXmlIdentityPolicy = {
+	canShareId(left, right) {
+		const leftSide = getReviewSide(left);
+		const rightSide = getReviewSide(right);
+		return Boolean(leftSide && rightSide && leftSide.group === rightSide.group && leftSide.side !== rightSide.side);
+	},
+	isIdentityNode(node) {
+		return isLiteXmlIdentityNode(node.getType());
+	},
+	project: getLiveProjection
+};
+//#endregion
 //#region src/plugins/litexml/diff-validation.ts
 const ACTIONABLE_DIFF_TYPES = /* @__PURE__ */ new Set([
 	"add",
@@ -1686,6 +1857,11 @@ const ACTIONABLE_DIFF_TYPES = /* @__PURE__ */ new Set([
 ]);
 const isActionableDiff = (node) => node?.type === "diff" && ACTIONABLE_DIFF_TYPES.has(node.diffType || "");
 const isElementNode = (node) => Array.isArray(node.children);
+const getNodeId = (node) => {
+	if (typeof node.id === "string" && node.id.length > 0) return node.id;
+	const properties = node.$?.properties;
+	return typeof properties?.nodeId === "string" ? properties.nodeId : void 0;
+};
 const cloneNode = (node) => structuredClone(node);
 function hasActionableDiffDescendant(node) {
 	return (node.children || []).some((child) => isActionableDiff(child) || hasActionableDiffDescendant(child));
@@ -1711,10 +1887,10 @@ function collectIllegalNestedDiffPaths(root) {
 		}
 		if (!isElementNode(node)) return;
 		node.children?.forEach((child) => {
-			visit(child, [...ancestors, node], `${path}/${child.id || child.type || "node"}`);
+			visit(child, [...ancestors, node], `${path}/${getNodeId(child) || child.type || "node"}`);
 		});
 	};
-	visit(root, [], root.id || root.type || "root");
+	visit(root, [], getNodeId(root) || root.type || "root");
 	return violations;
 }
 function findNewIllegalDiffPaths(previous, projected) {
@@ -1731,25 +1907,52 @@ function findNewIllegalDiffPaths(previous, projected) {
 	});
 	return newPaths;
 }
-function findNodeLocation(root, id, ancestors = []) {
-	if (root.id === id) return {
+function findActiveNodeLocation(root, id, ancestors = []) {
+	const projection = getLiteXmlIdentityProjection({
+		diffType: root.diffType,
+		firstChildDiffType: root.children?.[0]?.diffType,
+		firstChildType: root.children?.[0]?.type,
+		type: root.type
+	});
+	if (projection === "hidden") return null;
+	if (projection === "content" && getNodeId(root) === id) {
+		const parent = ancestors.at(-1) || null;
+		return {
+			ancestors,
+			index: parent ? (parent.children || []).indexOf(root) : -1,
+			node: root,
+			parent
+		};
+	}
+	const activeChildren = typeof projection === "object" ? root.children?.[projection.childIndex] ? [root.children[projection.childIndex]] : [] : root.children || [];
+	for (const child of activeChildren) {
+		const nested = findActiveNodeLocation(child, id, [...ancestors, root]);
+		if (nested) return nested;
+	}
+	return null;
+}
+function findNodeLocationByNode(root, target, ancestors = []) {
+	if (root === target) return {
 		ancestors,
 		index: -1,
 		node: root,
 		parent: null
 	};
 	for (const [index, child] of (root.children || []).entries()) {
-		if (child.id === id) return {
+		if (child === target) return {
 			ancestors: [...ancestors, root],
 			index,
 			node: child,
 			parent: root
 		};
-		const nested = findNodeLocation(child, id, [...ancestors, root]);
+		const nested = findNodeLocationByNode(child, target, [...ancestors, root]);
 		if (nested) return nested;
 	}
 	return null;
 }
+function hasActiveLiteXmlNodeId(root, id) {
+	return findActiveNodeLocation(root, id) !== null;
+}
 function replaceNode(location, replacements) {
 	if (!location.parent || location.index < 0) return;
 	location.parent.children?.splice(location.index, 1, ...replacements);
@@ -1769,8 +1972,9 @@ function createDiffContent(side, children) {
 	};
 }
 function projectModifyTarget(root, incoming) {
-	if (!incoming.id) return;
-	const location = findNodeLocation(root, incoming.id);
+	const incomingId = getNodeId(incoming);
+	if (!incomingId) return;
+	const location = findActiveNodeLocation(root, incomingId);
 	if (!location) return;
 	const target = location.node;
 	const next = cloneNode(incoming);
@@ -1804,10 +2008,30 @@ function projectModifyTarget(root, incoming) {
 		replaceNode(location, [next]);
 		return;
 	}
+	if (target.type === "listitem") {
+		const existingDiff = (target.children || []).find((child) => child.type === "diff");
+		if (existingDiff?.diffType === "listItemModify") {
+			const after = existingDiff.children?.[1];
+			if (after) after.children = cloneNode(next.children || []);
+			return;
+		}
+		if (existingDiff?.diffType === "listItemAdd") {
+			existingDiff.children = cloneNode(next.children || []);
+			return;
+		}
+		target.children = [createDiff("listItemModify", [{
+			children: cloneNode(target.children || []),
+			type: "paragraph"
+		}, {
+			children: cloneNode(next.children || []),
+			type: "paragraph"
+		}])];
+		return;
+	}
 	replaceNode(location, [createDiff("modify", [cloneNode(target), next])]);
 }
 function projectRemoveTarget(root, id) {
-	const location = findNodeLocation(root, id);
+	const location = findActiveNodeLocation(root, id);
 	if (!location) return;
 	if (location.ancestors.some(isActionableDiff)) {
 		replaceNode(location, []);
@@ -1834,13 +2058,13 @@ function projectRemoveTarget(root, id) {
 }
 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 reference = referenceId === "root" ? null : findActiveNodeLocation(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);
+	} : findActiveNodeLocation(root, referenceId);
 	if (!location) return;
 	const incoming = (readXml(operation.litexml).root?.children || []).map(cloneNode);
 	if (incoming.length === 0 || !location.parent) return;
@@ -1879,12 +2103,12 @@ function projectInsert(root, operation, readXml) {
 	].includes(node.type || ""));
 	if (!actionableAncestor && blockAncestor && hasActionableDiffDescendant(blockAncestor)) {
 		const wrapped = createDiff("modify", [cloneNode(blockAncestor), cloneNode(blockAncestor)]);
-		const blockLocation = findNodeLocation(root, blockAncestor.id || "");
+		const blockLocation = findNodeLocationByNode(root, blockAncestor);
 		if (blockLocation) replaceNode(blockLocation, [wrapped]);
 		return;
 	}
 	if (actionableAncestor && !isInlineReference) {
-		const originLocation = actionableAncestor.id ? findNodeLocation(root, actionableAncestor.id) : null;
+		const originLocation = findNodeLocationByNode(root, actionableAncestor);
 		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])));
@@ -2148,27 +2372,21 @@ function $isTableCellDiffNode(node) {
 }
 //#endregion
 //#region src/plugins/litexml/utils/index.ts
-const getNumericId$1 = (id) => {
-	if (typeof id !== "number" && typeof id !== "string") return null;
-	const numericId = Number(id);
-	return Number.isInteger(numericId) && numericId >= 0 ? numericId : null;
-};
-function $parseSerializedNodeImpl(serializedNode, editor, keepId = false, state = null) {
+function $parseSerializedNodeImpl(serializedNode, editor) {
 	const type = serializedNode.type;
 	const registeredNode = editor._nodes.get(type);
 	if (registeredNode === void 0) throw new Error(`parseEditorState: type "${type}" not found`);
 	const nodeClass = registeredNode.klass;
 	if (serializedNode.type !== nodeClass.getType()) throw new Error(`LexicalNode: Node ${nodeClass.name} does not implement .importJSON().`);
-	if (keepId) {
-		const id = getNumericId$1(serializedNode.id);
-		if (id !== null) resetRandomKey(id);
-	}
 	const node = nodeClass.importJSON(serializedNode);
+	const nodeId = isValidContentNodeId(serializedNode.id) ? serializedNode.id : $getNodeId(node);
+	if (isValidContentNodeId(nodeId)) $setNodeId(node, nodeId);
+	else if (nodeId) $clearNodeId(node);
 	const children = serializedNode.children;
 	if ($isElementNode(node) && Array.isArray(children)) {
 		const childNodes = [];
 		for (const serializedJSONChildNode of children) {
-			const childNode = $parseSerializedNodeImpl(serializedJSONChildNode, editor, keepId, state);
+			const childNode = $parseSerializedNodeImpl(serializedJSONChildNode, editor);
 			childNodes.push(childNode);
 		}
 		node.append(...childNodes);
@@ -2178,6 +2396,7 @@ function $parseSerializedNodeImpl(serializedNode, editor, keepId = false, state
 function exportNodeToJSON(node) {
 	const serializedNode = node.exportJSON();
 	const nodeClass = node.constructor;
+	serializedNode.id = $getNodeId(node);
 	if (serializedNode.type !== nodeClass.getType()) throw new Error(`LexicalNode: Node ${nodeClass.name} does not match the serialized type. Check if .exportJSON() is implemented and it is returning the correct type.`);
 	if ($isElementNode(node)) {
 		const serializedChildren = serializedNode.children;
@@ -2193,16 +2412,6 @@ function exportNodeToJSON(node) {
 function $cloneNode(node, editor) {
 	return $parseSerializedNodeImpl(exportNodeToJSON(node), editor);
 }
-const maxId = 1679616;
-const startId = 1e6;
-const step = 7211;
-const modInverse = 1394051;
-function idToChar(id) {
-	return ((Number(id) * step + startId) % maxId).toString(36).padStart(4, "0");
-}
-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) {
@@ -2212,6 +2421,7 @@ function copyCellStructure(source, target) {
 }
 function $createTableCellDiffFromCell(editor, cell, diffType, changeId) {
 	const diffCell = $createTableCellDiffNode(diffType, changeId, cell.getHeaderStyles(), cell.getColSpan(), cell.getWidth());
+	$copyNodeProperties(cell, diffCell);
 	copyCellStructure(cell, diffCell);
 	const diff = $createDiffNode(diffType);
 	diff.append(...cell.getChildren().map((child) => $cloneNode(child, editor)));
@@ -2220,6 +2430,7 @@ function $createTableCellDiffFromCell(editor, cell, diffType, changeId) {
 }
 function $createPlainTableCellFromDiff(editor, cell) {
 	const plainCell = $createTableCellNode(cell.getHeaderStyles(), cell.getColSpan(), cell.getWidth());
+	$copyNodeProperties(cell, plainCell);
 	copyCellStructure(cell, plainCell);
 	const diff = cell.getFirstChild();
 	if (diff instanceof DiffNode) plainCell.append(...diff.getChildren().map((child) => $cloneNode(child, editor)));
@@ -2434,11 +2645,13 @@ function $areTableRowStructuresCompatible(previousRow, nextRow) {
 function $createTableRowDiffFromRow(editor, row, diffType, changeId) {
 	const source = $cloneNode(row, editor);
 	const diffRow = $createTableRowDiffNode(diffType, changeId, row.getHeight());
+	$copyNodeProperties(row, diffRow);
 	diffRow.append(...source.getChildren());
 	return diffRow;
 }
 function $createPlainTableRowFromDiff(editor, row) {
 	const plainRow = $createTableRowNode(row.getHeight());
+	$copyNodeProperties(row, plainRow);
 	plainRow.append(...row.getChildren().map((child) => $cloneNode(child, editor)));
 	return plainRow;
 }
@@ -2506,9 +2719,9 @@ function toArrayXml(litexml) {
 function hasNewIllegalDiffs(previous, projected) {
 	return findNewIllegalDiffPaths(previous, projected);
 }
-function projectOperation(dataSource, document, operation) {
+function projectOperation(dataSource, document, operation, readXml = (xml) => dataSource.readLiteXMLToInode(xml)) {
 	try {
-		const projected = projectLiteXmlOperation(document, operation, (xml) => dataSource.readLiteXMLToInode(xml));
+		const projected = projectLiteXmlOperation(document, operation, readXml);
 		const newIllegalDiffs = hasNewIllegalDiffs(document, projected);
 		if (newIllegalDiffs.length > 0) {
 			logger$7.warn("⚠️ Skipping operation with illegal nested diff", newIllegalDiffs);
@@ -2521,19 +2734,163 @@ function projectOperation(dataSource, document, operation) {
 	}
 }
 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 getSerializedNodeId(node) {
+	if (typeof node?.id === "string" && node.id.length > 0) return node.id;
+	const nodeId = node?.$?.properties?.nodeId;
+	return typeof nodeId === "string" && nodeId.length > 0 ? nodeId : void 0;
+}
+function getActiveSerializedDocument() {
+	return { root: exportNodeToJSON$1($getRoot()) };
+}
+/** Resolve every target before staging any part of one modify operation. */
+function prepareModify(editor, dataSource, xmls) {
+	const pairs = [];
+	const parsed = /* @__PURE__ */ new Map();
+	const targetIds = /* @__PURE__ */ new Set();
+	for (const xml of xmls) {
+		const inode = dataSource.readLiteXMLToInode(xml);
+		parsed.set(xml, inode);
+		const children = inode.root?.children;
+		if (!children?.length) throw new Error("Modify operation contains no LiteXML nodes.");
+		for (const child of children) {
+			const nodeId = getSerializedNodeId(child);
+			if (!nodeId) throw new Error("Modify operation root is missing its public node id.");
+			if (targetIds.has(nodeId)) throw new Error(`Node id "${nodeId}" is targeted more than once.`);
+			targetIds.add(nodeId);
+			const oldNode = $findNodeById(nodeId);
+			if (!oldNode) throw new Error(`Node id "${nodeId}" was not found.`);
+			const newNode = $parseSerializedNodeImpl(child, editor);
+			if (oldNode.isInline() !== newNode.isInline()) throw new Error(`Node id "${nodeId}" cannot change between inline and block structure.`);
+			const parent = oldNode.getParent();
+			if (($isListNode(parent) || $isListItemNode(oldNode) || $isListItemNode(newNode)) && (!$isListNode(parent) || !$isListItemNode(oldNode) || !$isListItemNode(newNode))) throw new Error(`Node id "${nodeId}" has an incompatible list-item structure.`);
+			if ($isTableNode(parent) && (!$isTableRowNode(oldNode) || !$isTableRowNode(newNode)) || $isTableRowNode(parent) && (!$isTableCellNode(oldNode) || !$isTableCellNode(newNode)) || $isTableRowNode(newNode) && !$isTableNode(parent) || $isTableCellNode(newNode) && !$isTableRowNode(parent)) throw new Error(`Node id "${nodeId}" has an incompatible table structure.`);
+			if (($isTableRowNode(oldNode) || $isTableRowNode(newNode)) && (!$isTableRowNode(oldNode) || !$isTableRowNode(newNode) || !$isTableNode(parent) || !$areTableRowStructuresCompatible(oldNode, newNode))) throw new Error(`Node id "${nodeId}" has an incompatible table row structure.`);
+			pairs.push({
+				newNode,
+				oldNode
+			});
+		}
+	}
+	const targetKeys = new Set(pairs.map(({ oldNode }) => oldNode.getKey()));
+	for (const { oldNode } of pairs) for (let parent = oldNode.getParent(); parent; parent = parent.getParent()) if (targetKeys.has(parent.getKey())) throw new Error("Modify operation targets overlapping ancestor and descendant nodes.");
+	return {
+		pairs,
+		readXml: (xml) => parsed.get(xml)
+	};
+}
+function getBatchTargetError(document, operation, dataSource) {
+	if (operation.action === "remove") return hasActiveLiteXmlNodeId(document.root, operation.id) ? void 0 : `Node id "${operation.id}" was not found.`;
+	if (operation.action === "insert") {
+		try {
+			if (!dataSource.readLiteXMLToInode(operation.litexml).root.children?.length) return "Insert operation contains no LiteXML nodes.";
+		} catch (error) {
+			return error instanceof Error ? error.message : String(error);
+		}
+		const anchorId = "beforeId" in operation ? operation.beforeId : operation.afterId;
+		if (anchorId === "root") return (document.root.children?.length || 0) > 0 ? void 0 : "The document has no node to use as an insertion anchor.";
+		return hasActiveLiteXmlNodeId(document.root, anchorId) ? void 0 : `Insertion anchor "${anchorId}" was not found.`;
+	}
+}
+function applyLiteXMLBatch(editor, dataSource, operations) {
+	let projectedDocument = getActiveSerializedDocument();
+	const afterAnchors = /* @__PURE__ */ new Map();
+	const results = [];
+	operations.forEach((operation, index) => {
+		const targetError = getBatchTargetError(projectedDocument, operation, dataSource);
+		if (targetError) {
+			results.push({
+				action: operation.action,
+				index,
+				reason: targetError,
+				status: "failed"
+			});
+			return;
+		}
+		let preparedModify;
+		if (operation.action === "modify") try {
+			preparedModify = prepareModify(editor, dataSource, toArrayXml(operation.litexml));
+		} catch (error) {
+			results.push({
+				action: operation.action,
+				index,
+				reason: error instanceof Error ? error.message : String(error),
+				status: "failed"
+			});
+			return;
+		}
+		if (!projectOperation(dataSource, projectedDocument, toProjectionOperation(operation), preparedModify?.readXml)) {
+			results.push({
+				action: operation.action,
+				index,
+				reason: "The operation would create an invalid nested review diff.",
+				status: "failed"
+			});
+			return;
+		}
+		try {
+			let applied = false;
+			switch (operation.action) {
+				case "modify":
+					applied = applyPreparedModify(editor, preparedModify);
+					break;
+				case "remove":
+					applied = handleRemove(editor, operation.id, true);
+					break;
+				case "insert": {
+					const cursorIds = "afterId" in operation ? afterAnchors.get(operation.afterId) : void 0;
+					let override;
+					if (cursorIds) for (let cursorIndex = cursorIds.length - 1; cursorIndex >= 0; cursorIndex--) {
+						const cursor = $findNodeById(cursorIds[cursorIndex]);
+						if (cursor) {
+							override = cursor;
+							break;
+						}
+					}
+					const insertedNodeId = handleInsert(editor, {
+						...operation,
+						delay: true
+					}, dataSource, override);
+					applied = insertedNodeId !== null;
+					if ("afterId" in operation && insertedNodeId) {
+						const nextCursors = afterAnchors.get(operation.afterId) || [];
+						nextCursors.push(insertedNodeId);
+						afterAnchors.set(operation.afterId, nextCursors);
+					}
+					break;
+				}
+			}
+			if (!applied) {
+				results.push({
+					action: operation.action,
+					index,
+					reason: "The editor could not apply the operation.",
+					status: "failed"
+				});
+				return;
+			}
+			projectedDocument = getActiveSerializedDocument();
+			results.push({
+				action: operation.action,
+				index,
+				status: "applied"
+			});
+		} catch (error) {
+			results.push({
+				action: operation.action,
+				index,
+				reason: error instanceof Error ? error.message : String(error),
+				status: "failed"
+			});
+		}
+	});
+	return results;
+}
 function tryParseChild(child, editor) {
 	try {
-		const oldNode = $getNodeByKey(child.id);
+		const nodeId = typeof child.id === "string" ? child.id : child.$?.properties?.nodeId;
+		const oldNode = typeof nodeId === "string" ? $findNodeById(nodeId) : null;
 		return {
 			newNode: $parseSerializedNodeImpl(child, editor),
 			oldNode
@@ -2550,14 +2907,14 @@ function handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNode
 	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;
+			return false;
 		}
 		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;
+		return true;
 	}
 	if ($isTableCellNode(oldNode) && $isTableCellNode(newNode)) {
 		const existingDiff = oldNode.getChildren().find($isDiffNode);
@@ -2567,7 +2924,7 @@ function handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNode
 				newNode.getChildren().forEach((child) => {
 					existingDiff.append($cloneNode(child, editor));
 				});
-				return;
+				return true;
 			}
 			const after = existingDiff.getChildren().find((child) => $isDiffContentNode(child) && child.side === "after");
 			if (existingDiff.diffType === "modify" && after && $isDiffContentNode(after)) {
@@ -2575,7 +2932,7 @@ function handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNode
 				newNode.getChildren().forEach((child) => {
 					after.append($cloneNode(child, editor));
 				});
-				return;
+				return true;
 			}
 		}
 		const before = $createDiffContentNode("before");
@@ -2586,27 +2943,42 @@ function handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNode
 		diffNode.append(before, after);
 		oldNode.clear();
 		oldNode.append(diffNode);
-		return;
+		return true;
 	}
 	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;
+		return true;
 	}
 	if ($isListItemNode(oldNode) && $isListItemNode(newNode)) {
+		const existingListDiff = oldNode.getChildren().find($isDiffNode);
+		if (existingListDiff?.diffType === "listItemModify") {
+			const after = existingListDiff.getChildAtIndex(1);
+			if ($isElementNode(after)) {
+				after.clear();
+				newNode.getChildren().forEach((child) => after.append($cloneNode(child, editor)));
+				return true;
+			}
+		}
+		if (existingListDiff?.diffType === "listItemAdd") {
+			existingListDiff.clear();
+			newNode.getChildren().forEach((child) => existingListDiff.append($cloneNode(child, editor)));
+			return true;
+		}
 		const before = $createParagraphNode();
 		const after = $createParagraphNode();
 		oldNode.getChildren().forEach((child) => before.append(child));
 		newNode.getChildren().forEach((child) => after.append(child));
 		oldNode.clear();
 		oldNode.append($createDiffNode("listItemModify").append(before, after));
-		return;
+		return true;
 	}
 	if (oldNode === oldBlock) {
 		const diffNode = $createDiffNode("modify");
 		oldNode.replace(diffNode, false);
 		diffNode.append($createDiffContentNode("before").append(oldBlock), $createDiffContentNode("after").append(newNode));
+		return true;
 	} else {
 		if (!modifyBlockNodes.has(oldBlock.getKey())) {
 			modifyBlockNodes.add(oldBlock.getKey());
@@ -2615,6 +2987,7 @@ function handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNode
 			diffNodeMap.set(oldBlock.getKey(), diffNode);
 		}
 		oldNode.replace(newNode, false);
+		return true;
 	}
 }
 function finalizeModifyBlocks(modifyBlockNodes, diffNodeMap, editor) {
@@ -2635,6 +3008,16 @@ function finalizeModifyBlocks(modifyBlockNodes, diffNodeMap, editor) {
 				newDiffNode.append(p);
 				blockNode.append(newDiffNode);
 				continue;
+			} else if ($isTableCellNode(blockNode) && $isTableRowNode(blockNode.getParent()) && $isTableCellNode(diffNode.getFirstChild())) {
+				const beforeCell = diffNode.getFirstChild();
+				if (!$isTableCellNode(beforeCell)) continue;
+				const before = $createDiffContentNode("before");
+				const after = $createDiffContentNode("after");
+				beforeCell.getChildren().forEach((child) => before.append(child));
+				blockNode.getChildren().forEach((child) => after.append($cloneNode(child, editor)));
+				blockNode.clear();
+				blockNode.append($createDiffNode("modify").append(before, after));
+				continue;
 			} else {
 				diffNode.append($cloneNode(blockNode, editor));
 				blockNode.replace(diffNode, false);
@@ -2665,6 +3048,18 @@ function wrapBlockModify(oldBlock, editor, changeFn) {
 		oldBlock.append(diffNode);
 		return;
 	}
+	if ($isTableCellNode(oldBlock) && !$isTableCellDiffNode(oldBlock) && $isTableRowNode(oldBlock.getParent())) {
+		const before = $createDiffContentNode("before");
+		oldBlock.getChildren().forEach((child) => before.append($cloneNode(child, editor)));
+		changeFn();
+		const newBlock = $getNodeByKey(oldBlock.getKey());
+		if (!$isTableCellNode(newBlock)) throw new Error("Updated table cell node not found for modify wrapper.");
+		const after = $createDiffContentNode("after");
+		newBlock.getChildren().forEach((child) => after.append($cloneNode(child, editor)));
+		newBlock.clear();
+		newBlock.append($createDiffNode("modify").append(before, after));
+		return;
+	}
 	const diffNode = $createDiffNode("modify");
 	diffNode.append($cloneNode(oldBlock, editor));
 	changeFn();
@@ -2674,344 +3069,330 @@ function wrapBlockModify(oldBlock, editor, changeFn) {
 	newBlock.replace(diffNode, false);
 }
 function registerLiteXMLCommand(editor, dataSource) {
-	return mergeRegister(editor.registerCommand(LITEXML_MODIFY_COMMAND, (payload) => {
-		const resultPayload = payload.reduce((acc, cur) => {
-			if (cur.action === "insert") acc.unshift(cur);
-			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 {
-			safePayload.forEach((item) => {
-				const { action } = item;
-				switch (action) {
-					case "modify": {
-						const { litexml } = item;
-						handleModify(editor, dataSource, toArrayXml(litexml), true);
-						break;
-					}
-					case "remove": {
-						const { id } = item;
-						handleRemove(editor, charToId(id), true);
-						break;
-					}
-					case "insert":
-						handleInsert(editor, {
-							...item,
-							delay: true
-						}, dataSource);
-						break;
-					default: logger$7.warn(`⚠️ Unknown action type: ${action}`);
-				}
-			});
-			return false;
-		} catch (error) {
-			logger$7.error("❌ Error processing LITEXML_MODIFY_COMMAND:", error);
-			return false;
-		}
+	return mergeRegister(editor.registerCommand(LITEXML_MODIFY_COMMAND, (operations) => {
+		applyLiteXMLBatch(editor, dataSource, operations);
+		return false;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_MODIFY_WITH_RESULTS_COMMAND, ({ operations, onResults }) => {
+		onResults(applyLiteXMLBatch(editor, dataSource, operations));
+		return true;
 	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_APPLY_COMMAND, (payload) => {
 		const { litexml, delay } = payload;
 		const arrayXml = toArrayXml(litexml);
 		if (!delay) {
-			handleModify(editor, dataSource, arrayXml, delay);
+			handleModify(editor, dataSource, arrayXml);
 			return false;
 		}
 		const operation = {
 			action: "modify",
 			litexml
 		};
-		if (projectOperation(dataSource, getKernelFromEditor(editor).getDocument("json"), toProjectionOperation(operation))) handleModify(editor, dataSource, arrayXml, delay);
+		const document = getActiveSerializedDocument();
+		try {
+			const prepared = prepareModify(editor, dataSource, arrayXml);
+			if (projectOperation(dataSource, document, toProjectionOperation(operation), prepared.readXml)) applyPreparedModify(editor, prepared);
+		} catch (error) {
+			logger$7.error("❌ Failed to apply LiteXML modification:", error);
+		}
 		return false;
 	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_REMOVE_COMMAND, (payload) => {
 		const { id, delay } = payload;
-		const key = charToId(id);
 		if (!delay) {
-			handleRemove(editor, key, delay);
+			handleRemove(editor, id, delay);
 			return false;
 		}
 		const operation = {
 			action: "remove",
 			id
 		};
-		if (projectOperation(dataSource, getKernelFromEditor(editor).getDocument("json"), toProjectionOperation(operation))) handleRemove(editor, key, delay);
+		if (projectOperation(dataSource, getActiveSerializedDocument(), toProjectionOperation(operation))) handleRemove(editor, id, delay);
 		return false;
 	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_INSERT_COMMAND, (payload) => {
 		if (!payload.delay) {
 			handleInsert(editor, payload, dataSource);
 			return false;
 		}
-		if (projectOperation(dataSource, getKernelFromEditor(editor).getDocument("json"), toProjectionOperation({
+		if (projectOperation(dataSource, getActiveSerializedDocument(), toProjectionOperation({
 			action: "insert",
 			...payload
 		}))) handleInsert(editor, payload, dataSource);
 		return false;
 	}, COMMAND_PRIORITY_EDITOR));
 }
-function handleModify(editor, dataSource, arrayXml, delay) {
-	if (delay) editor.update(() => {
-		const modifyBlockNodes = /* @__PURE__ */ new Set();
-		const diffNodeMap = /* @__PURE__ */ new Map();
-		arrayXml.forEach((xml) => {
-			dataSource.readLiteXMLToInode(xml).root.children.forEach((child) => {
-				try {
-					const { oldNode, newNode } = tryParseChild(child, editor);
-					if (oldNode && newNode) handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNodeMap, editor);
-					else logger$7.warn(`⚠️ Node with key ${child.id} not found for diffing.`);
-				} catch (error) {
-					logger$7.error("❌ Error replacing node:", error);
-				}
-			});
-		});
-		finalizeModifyBlocks(modifyBlockNodes, diffNodeMap, editor);
-	});
-	else editor.update(() => {
-		arrayXml.forEach((xml) => {
-			const inode = dataSource.readLiteXMLToInode(xml);
-			let prevNode = null;
-			inode.root.children.forEach((child) => {
-				try {
-					const { oldNode, newNode } = tryParseChild(child, editor);
-					if (oldNode && newNode) prevNode = oldNode.replace(newNode, false);
-					else if (newNode) {
-						if (prevNode) {
-							if (!newNode.isInline()) {
-								const prevBlock = $closest(prevNode, (node) => node.isInline() === false);
-								if (prevBlock) prevNode = prevBlock.insertAfter(newNode);
-								else {
-									$insertNodes([newNode]);
-									prevNode = newNode;
-								}
-							} else prevNode = prevNode.insertAfter(newNode);
-						} else $insertNodes([newNode]);
+function applyPreparedModify(editor, prepared) {
+	const modifyBlockNodes = /* @__PURE__ */ new Set();
+	const diffNodeMap = /* @__PURE__ */ new Map();
+	for (const { oldNode, newNode } of prepared.pairs) if (!handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNodeMap, editor)) throw new Error(`Node id "${$getNodeId(oldNode)}" could not be modified.`);
+	finalizeModifyBlocks(modifyBlockNodes, diffNodeMap, editor);
+	return prepared.pairs.length > 0;
+}
+function handleModify(editor, dataSource, arrayXml) {
+	let applied = false;
+	arrayXml.forEach((xml) => {
+		const inode = dataSource.readLiteXMLToInode(xml);
+		let prevNode = null;
+		inode.root.children.forEach((child) => {
+			try {
+				const { oldNode, newNode } = tryParseChild(child, editor);
+				if (oldNode && newNode) {
+					prevNode = oldNode.replace(newNode, false);
+					applied = true;
+				} else if (newNode) {
+					if (prevNode) {
+						if (!newNode.isInline()) {
+							const prevBlock = $closest(prevNode, (node) => node.isInline() === false);
+							if (prevBlock) prevNode = prevBlock.insertAfter(newNode);
+							else {
+								$insertNodes([newNode]);
+								prevNode = newNode;
+							}
+							applied = true;
+						} else {
+							prevNode = prevNode.insertAfter(newNode);
+							applied = true;
+						}
+					} else {
+						$insertNodes([newNode]);
+						applied = true;
 					}
-				} catch (error) {
-					logger$7.error("❌ Error replacing node:", error);
 				}
-			});
+			} catch (error) {
+				logger$7.error("❌ Error replacing node:", error);
+			}
 		});
 	});
+	return applied;
 }
-function handleRemove(editor, key, delay) {
-	editor.update(() => {
-		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;
-		}
+function handleRemove(editor, nodeId, delay) {
+	let applied = false;
+	const node = $findNodeById(nodeId);
+	if (!node) return false;
+	if (!delay) {
 		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;
+			const span = node.getColSpan();
+			node.remove();
+			applied = true;
+			if (table && columnIndex >= 0) $shrinkTableWidthsAfterCellRemoval(table, columnIndex, span);
+			return true;
 		}
-		if ($isTableRowNode(node) && $isTableNode(node.getParent())) {
-			node.replace($createTableRowDiffFromRow(editor, node, "remove"), false);
-			return;
+		node.remove();
+		applied = true;
+		return true;
+	}
+	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 false;
 		}
-		if (node.isInline() === false) {
-			const originDiffNode = $closest(node, (node) => node.getType() === DiffNode.getType());
-			if (originDiffNode) {
-				switch (originDiffNode.diffType) {
-					case "add":
-						originDiffNode.remove();
-						return;
-					case "modify": {
-						const children = originDiffNode.getChildren();
-						const newDiff = $createDiffNode("remove");
-						const before = children[0];
-						newDiff.append(...$isDiffContentNode(before) ? before.getChildren() : [before]);
-						originDiffNode.replace(newDiff, false);
-						return;
-					}
-					case "listItemModify": {
-						const children = originDiffNode.getChildren();
-						originDiffNode.replace(children[0], false).selectEnd();
-						return;
-					}
+		const changeId = `${table.getKey()}:column:${columnIndex}`;
+		node.replace($createTableCellDiffFromCell(editor, node, "remove", changeId), false);
+		applied = true;
+		return true;
+	}
+	if ($isTableRowNode(node) && $isTableNode(node.getParent())) {
+		node.replace($createTableRowDiffFromRow(editor, node, "remove"), false);
+		applied = true;
+		return true;
+	}
+	if (node.isInline() === false) {
+		const originDiffNode = $closest(node, (node) => node.getType() === DiffNode.getType());
+		if (originDiffNode) {
+			switch (originDiffNode.diffType) {
+				case "add":
+					originDiffNode.remove();
+					applied = true;
+					return true;
+				case "modify": {
+					const children = originDiffNode.getChildren();
+					const newDiff = $createDiffNode("remove");
+					const before = children[0];
+					newDiff.append(...$isDiffContentNode(before) ? before.getChildren() : [before]);
+					originDiffNode.replace(newDiff, false);
+					applied = true;
+					return true;
+				}
+				case "listItemModify": {
+					const children = originDiffNode.getChildren();
+					originDiffNode.replace(children[0], false).selectEnd();
+					applied = true;
+					return true;
 				}
-				return;
-			}
-			if ($isListItemNode(node)) {
-				const diffNode = $createDiffNode("listItemRemove");
-				node.getChildren().forEach((child) => {
-					diffNode.append($cloneNode(child, editor));
-				});
-				node.clear();
-				node.append(diffNode);
-			} else {
-				const diffNode = $createDiffNode("remove");
-				diffNode.append($cloneNode(node, editor));
-				node.replace(diffNode, false);
-			}
-		} else {
-			const oldBlock = $closest(node, (node) => node.isInline() === false);
-			if (!oldBlock) throw new Error("Old block node not found for removal.");
-			if ($closest(node, (node) => node.getType() === DiffNode.getType())) {
-				node.remove();
-				return;
 			}
-			wrapBlockModify(oldBlock, editor, () => {
-				node.remove();
+			return false;
+		}
+		if ($isListItemNode(node)) {
+			const diffNode = $createDiffNode("listItemRemove");
+			node.getChildren().forEach((child) => {
+				diffNode.append($cloneNode(child, editor));
 			});
+			node.clear();
+			node.append(diffNode);
+			applied = true;
+		} else {
+			const diffNode = $createDiffNode("remove");
+			diffNode.append($cloneNode(node, editor));
+			node.replace(diffNode, false);
+			applied = true;
 		}
-	});
+	} else {
+		const oldBlock = $closest(node, (node) => node.isInline() === false);
+		if (!oldBlock) throw new Error("Old block node not found for removal.");
+		if ($closest(node, (node) => node.getType() === DiffNode.getType())) {
+			node.remove();
+			applied = true;
+			return true;
+		}
+		wrapBlockModify(oldBlock, editor, () => {
+			node.remove();
+		});
+		applied = true;
+	}
+	return applied;
 }
-function handleInsert(editor, payload, dataSource) {
+function handleInsert(editor, payload, dataSource, referenceNodeOverride) {
 	const { litexml, delay } = payload;
 	const isBefore = "beforeId" in payload;
 	const inode = dataSource.readLiteXMLToInode(litexml);
-	editor.update(() => {
-		try {
-			let referenceNode = null;
+	let insertedNodeId = null;
+	try {
+		let referenceNode = referenceNodeOverride || null;
+		if (!referenceNode) {
 			if (isBefore) {
 				if (payload.beforeId === "root") referenceNode = $getRoot().getFirstChild();
-				else referenceNode = $getNodeByKey(charToId(payload.beforeId));
+				else referenceNode = $findNodeById(payload.beforeId);
 			} else if (payload.afterId === "root") referenceNode = $getRoot().getLastChild();
-			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;
+			else referenceNode = $findNodeById(payload.afterId);
+		}
+		if (!referenceNode) throw new Error("Reference node not found for insertion.");
+		const newNodes = inode.root.children.map((child) => $parseSerializedNodeImpl(child, editor));
+		$ensureUniqueNodeIds(newNodes);
+		insertedNodeId = newNodes.length ? $getNodeId(newNodes.at(-1)) || null : null;
+		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 null;
 			}
-			if (!delay) {
-				if (isBefore) newNodes.reverse().forEach((node) => {
-					referenceNode = referenceNode.insertBefore(node);
-				});
-				else newNodes.forEach((node) => {
-					if (referenceNode) referenceNode = referenceNode.insertAfter(node);
-				});
-				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 null;
 			}
-			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;
+			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 insertedNodeId;
+		}
+		if (!delay) {
+			if (isBefore) newNodes.reverse().forEach((node) => {
+				referenceNode = referenceNode.insertBefore(node);
+			});
+			else newNodes.forEach((node) => {
+				if (referenceNode) referenceNode = referenceNode.insertAfter(node);
+			});
+			return insertedNodeId;
+		}
+		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 null;
 			}
-			if (isBefore) {
-				if (referenceNode.isInline() === false) {
-					const originDiffNode = $closest(referenceNode, (node) => node.getType() === DiffNode.getType());
-					if (originDiffNode) referenceNode = originDiffNode;
-					newNodes.map((node) => {
-						if ($isListItemNode(node)) {
-							const diffNode = $createDiffNode("listItemAdd");
-							node.getChildren().forEach((child) => diffNode.append(child));
-							return node.append(diffNode);
-						}
-						const diffNode = $createDiffNode("add");
-						diffNode.append(node);
-						return diffNode;
-					}).reverse().forEach((diffNode) => {
-						if (referenceNode) referenceNode = referenceNode.insertBefore(diffNode);
-					});
-				} else {
-					const refBlock = $closest(referenceNode, (node) => node.isInline() === false);
-					if (!refBlock) throw new Error("Reference block node not found for insertion.");
-					if ($closest(referenceNode, (node) => node.getType() === DiffNode.getType())) newNodes.forEach((node) => {
-						if (referenceNode) referenceNode = referenceNode.insertBefore(node);
-					});
-					else wrapBlockModify(refBlock, editor, () => {
-						newNodes.forEach((node) => {
-							if (referenceNode) referenceNode = referenceNode.insertBefore(node);
-						});
-					});
-				}
-			} else if (referenceNode.isInline() === false) {
+			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 insertedNodeId;
+		}
+		if (isBefore) {
+			if (referenceNode.isInline() === false) {
 				const originDiffNode = $closest(referenceNode, (node) => node.getType() === DiffNode.getType());
 				if (originDiffNode) referenceNode = originDiffNode;
-				newNodes.forEach((node) => {
-					if (referenceNode) {
-						if ($isListItemNode(node)) {
-							const diffNode = $createDiffNode("listItemAdd");
-							node.getChildren().forEach((child) => {
-								diffNode.append(child);
-							});
-							node.append(diffNode);
-							referenceNode = referenceNode.insertAfter(node);
-						} else {
-							const diffNode = $createDiffNode("add");
-							diffNode.append(node);
-							referenceNode = referenceNode.insertAfter(diffNode);
-						}
+				newNodes.map((node) => {
+					if ($isListItemNode(node)) {
+						const diffNode = $createDiffNode("listItemAdd");
+						node.getChildren().forEach((child) => diffNode.append(child));
+						return node.append(diffNode);
 					}
+					const diffNode = $createDiffNode("add");
+					diffNode.append(node);
+					return diffNode;
+				}).reverse().forEach((diffNode) => {
+					if (referenceNode) referenceNode = referenceNode.insertBefore(diffNode);
 				});
 			} else {
 				const refBlock = $closest(referenceNode, (node) => node.isInline() === false);
 				if (!refBlock) throw new Error("Reference block node not found for insertion.");
 				if ($closest(referenceNode, (node) => node.getType() === DiffNode.getType())) newNodes.forEach((node) => {
-					if (referenceNode) referenceNode = referenceNode.insertAfter(node);
+					if (referenceNode) referenceNode = referenceNode.insertBefore(node);
 				});
 				else wrapBlockModify(refBlock, editor, () => {
 					newNodes.forEach((node) => {
-						if (referenceNode) referenceNode = referenceNode.insertAfter(node);
+						if (referenceNode) referenceNode = referenceNode.insertBefore(node);
 					});
 				});
 			}
-		} catch (error) {
-			logger$7.error("❌ Error inserting node:", error);
+		} else if (referenceNode.isInline() === false) {
+			const originDiffNode = $closest(referenceNode, (node) => node.getType() === DiffNode.getType());
+			if (originDiffNode) referenceNode = originDiffNode;
+			newNodes.forEach((node) => {
+				if (referenceNode) {
+					if ($isListItemNode(node)) {
+						const diffNode = $createDiffNode("listItemAdd");
+						node.getChildren().forEach((child) => {
+							diffNode.append(child);
+						});
+						node.append(diffNode);
+						referenceNode = referenceNode.insertAfter(node);
+					} else {
+						const diffNode = $createDiffNode("add");
+						diffNode.append(node);
+						referenceNode = referenceNode.insertAfter(diffNode);
+					}
+				}
+			});
+		} else {
+			const refBlock = $closest(referenceNode, (node) => node.isInline() === false);
+			if (!refBlock) throw new Error("Reference block node not found for insertion.");
+			if ($closest(referenceNode, (node) => node.getType() === DiffNode.getType())) newNodes.forEach((node) => {
+				if (referenceNode) referenceNode = referenceNode.insertAfter(node);
+			});
+			else wrapBlockModify(refBlock, editor, () => {
+				newNodes.forEach((node) => {
+					if (referenceNode) referenceNode = referenceNode.insertAfter(node);
+				});
+			});
 		}
-	});
+	} catch (error) {
+		logger$7.error("❌ Error inserting node:", error);
+		insertedNodeId = null;
+	}
+	return insertedNodeId;
 }
 //#endregion
 //#region src/plugins/litexml/command/diffCommand.ts
@@ -3294,13 +3675,8 @@ var LitexmlDataSource = class extends DataSource {
 	read(editor, data) {
 		try {
 			const inode = this.readLiteXMLToInode(data);
-			const newState = editor.parseEditorState({ root: INodeHelper.createRootNode() }, (state) => {
-				try {
-					const root = $parseSerializedNodeImpl(inode.root, editor, true, state);
-					state._nodeMap.set(root.getKey(), root);
-				} catch (error) {
-					console.error(error);
-				}
+			const newState = editor.parseEditorState(inode, () => {
+				$normalizeNodeIds($getRoot());
 			});
 			editor.setEditorState(newState);
 		} catch (error) {
@@ -3366,6 +3742,22 @@ var LitexmlDataSource = class extends DataSource {
 	processXMLElement(xmlElement, parentNode) {
 		const tagName = xmlElement.tagName.toLowerCase();
 		const customReaders = this.litexmlService.getXMLReaders();
+		const publicId = xmlElement.getAttribute("id") || void 0;
+		const attachPublicId = (node, id = publicId) => {
+			if (!node || !id) return;
+			node.id = id;
+			node.$ = {
+				...node.$,
+				properties: {
+					...node.$?.properties,
+					nodeId: id
+				}
+			};
+		};
+		const append = (node) => {
+			attachPublicId(node);
+			INodeHelper.appendChild(parentNode, node);
+		};
 		if (customReaders[tagName]) {
 			const readerOrReaders = customReaders[tagName];
 			const readers = Array.isArray(readerOrReaders) ? readerOrReaders : [readerOrReaders];
@@ -3375,16 +3767,9 @@ var LitexmlDataSource = class extends DataSource {
 				const result = reader(xmlElement, children);
 				if (result !== false) {
 					if (Array.isArray(result)) {
-						if (result.length > 0) {
-							const attrId = xmlElement.getAttribute("id");
-							result[0].id = attrId ? charToId(attrId) : void 0;
-						}
+						if (result.length > 0) attachPublicId(result[0]);
 						INodeHelper.appendChild(parentNode, ...result);
-					} else if (result) {
-						const attrId = xmlElement.getAttribute("id");
-						result.id = attrId ? charToId(attrId) : void 0;
-						INodeHelper.appendChild(parentNode, result);
-					}
+					} else if (result) append(result);
 					return;
 				}
 			}
@@ -3394,7 +3779,7 @@ var LitexmlDataSource = class extends DataSource {
 			case "paragraph": {
 				const paragraph = INodeHelper.createParagraph();
 				this.processXMLChildren(xmlElement, paragraph);
-				INodeHelper.appendChild(parentNode, paragraph);
+				append(paragraph);
 				break;
 			}
 			case "h1":
@@ -3409,7 +3794,7 @@ var LitexmlDataSource = class extends DataSource {
 					tag: `h${level}`
 				});
 				this.processXMLChildren(xmlElement, heading);
-				INodeHelper.appendChild(parentNode, heading);
+				append(heading);
 				break;
 			}
 			case "ul":
@@ -3421,6 +3806,7 @@ var LitexmlDataSource = class extends DataSource {
 						children: [],
 						value: 1
 					});
+					attachPublicId(listItem, child.getAttribute("id") || void 0);
 					this.processXMLChildren(child, listItem);
 					INodeHelper.appendChild(parentNode, listItem);
 				});
@@ -3428,20 +3814,15 @@ var LitexmlDataSource = class extends DataSource {
 			case "blockquote": {
 				const quote = INodeHelper.createElementNode("quote", { children: [] });
 				this.processXMLChildren(xmlElement, quote);
-				INodeHelper.appendChild(parentNode, quote);
+				append(quote);
 				break;
 			}
-			case "code": {
-				const codeNode = INodeHelper.createElementNode("codeInline", { children: [INodeHelper.createTextNode(xmlElement.textContent || "")] });
-				INodeHelper.appendChild(parentNode, codeNode);
+			case "code":
+				append(INodeHelper.createElementNode("codeInline", { children: [INodeHelper.createTextNode(xmlElement.textContent || "")] }));
 				break;
-			}
 			case "text": {
 				const textContent = xmlElement.textContent || "";
-				if (textContent) {
-					const textNode = INodeHelper.createTextNode(textContent);
-					INodeHelper.appendChild(parentNode, textNode);
-				}
+				if (textContent) append(INodeHelper.createTextNode(textContent));
 				break;
 			}
 			default: this.processXMLChildren(xmlElement, parentNode);
@@ -3492,10 +3873,12 @@ var LitexmlDataSource = class extends DataSource {
 						lines.push(...handled.lines);
 						return;
 					}
-					const attrs = this.buildXMLAttributes({
-						id: idToChar(node.getKey()),
+					const attributes = {
+						id: $getNodeId(node),
 						...handled.attributes
-					});
+					};
+					attributes.id = $getNodeId(node);
+					const attrs = this.buildXMLAttributes(attributes);
 					const openTag = `${indentStr}<${handled.tagName}${attrs}>`;
 					const closeTag = `</${handled.tagName}>`;
 					if (handled.textContent) lines.push(`${openTag}${handled.textContent}${closeTag}`);
@@ -3527,7 +3910,7 @@ var LitexmlDataSource = class extends DataSource {
 	* Escape XML special characters
 	*/
 	escapeXML(text) {
-		return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+		return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;").replaceAll("	", "&#9;").replaceAll("\n", "&#10;").replaceAll("\r", "&#13;");
 	}
 };
 //#endregion
@@ -3900,6 +4283,74 @@ const SPICAL_TEXT = "￰";
 const getLineNumber = (content, charIndex) => {
 	return content.slice(0, Math.max(0, charIndex)).split("\n").length;
 };
+function getNodeReferenceForKey(editor, key) {
+	return editor.getEditorState().read(() => {
+		const node = $getNodeByKey(key);
+		if (!node) return null;
+		if ($isRootNode(node)) return { kind: "root" };
+		const id = $getNodeId(node);
+		return id ? {
+			id,
+			kind: "node"
+		} : null;
+	});
+}
+function getNodeKeyForReference(editor, reference, offset) {
+	return editor.getEditorState().read(() => {
+		if (reference.kind === "node") {
+			const node = $findNodeById(reference.id);
+			return node ? {
+				key: node.getKey(),
+				offset
+			} : void 0;
+		}
+		const root = $getRoot();
+		const findBoundaryText = (node, first) => {
+			if ($isTextNode(node)) return node;
+			if (!$isElementNode(node)) return null;
+			const children = node.getChildren();
+			const orderedChildren = first ? children : [...children].reverse();
+			for (const child of orderedChildren) {
+				const textNode = findBoundaryText(child, first);
+				if (textNode) return textNode;
+			}
+			return null;
+		};
+		if (offset === 0) {
+			const firstText = findBoundaryText(root, true);
+			if (firstText) return {
+				key: firstText.getKey(),
+				offset: 0
+			};
+		}
+		if (offset === root.getChildrenSize()) {
+			const lastText = findBoundaryText(root, false);
+			if (lastText) return {
+				key: lastText.getKey(),
+				offset: lastText.getTextContentSize()
+			};
+		}
+		return {
+			key: root.getKey(),
+			offset
+		};
+	}, { editor });
+}
+function mapSelectionToEditor(selection, sourceEditor, targetEditor) {
+	const startReference = getNodeReferenceForKey(sourceEditor, selection.startNodeId);
+	const endReference = getNodeReferenceForKey(sourceEditor, selection.endNodeId);
+	if (!startReference || !endReference) return null;
+	const startPoint = getNodeKeyForReference(targetEditor, startReference, selection.startOffset);
+	const endPoint = getNodeKeyForReference(targetEditor, endReference, selection.endOffset);
+	if (!startPoint || !endPoint) return null;
+	return {
+		...selection,
+		endNodeId: endPoint.key,
+		endOffset: endPoint.offset,
+		startNodeId: startPoint.key,
+		startOffset: startPoint.offset
+	};
+}
 function registerMarkdownCommand(editor, kernel, service) {
 	return mergeRegister(editor.registerCommand(INSERT_MARKDOWN_COMMAND, (payload) => {
 		const { markdown } = payload;
@@ -3922,9 +4373,12 @@ function registerMarkdownCommand(editor, kernel, service) {
 		return false;
 	}, COMMAND_PRIORITY_HIGH), editor.registerCommand(GET_MARKDOWN_SELECTION_COMMAND, (payload) => {
 		const newEditor = kernel.cloneNodeEditor();
-		const s = kernel.getSelection();
-		if (s) {
-			newEditor.setSelection(s);
+		const sourceEditor = kernel.getLexicalEditor();
+		const selection = kernel.getSelection();
+		const targetEditor = newEditor.getLexicalEditor();
+		const mappedSelection = sourceEditor && targetEditor && selection ? mapSelectionToEditor(selection, sourceEditor, targetEditor) : null;
+		if (mappedSelection && targetEditor) {
+			newEditor.setSelection(mappedSelection);
 			newEditor.getLexicalEditor()?.update(() => {
 				const sel = $getSelection();
 				if (!sel) return;
@@ -4021,7 +4475,10 @@ var MarkdownDataSource = class extends DataSource {
 		const inode = { root: parseMarkdownToLexical(data, this.markdownService.markdownReaders) };
 		this.getService?.(INodeService)?.processNodeTree(inode);
 		logger$5.debug("Parsed Lexical State:", inode);
-		editor.setEditorState(editor.parseEditorState(inode));
+		const editorState = editor.parseEditorState(inode, () => {
+			$normalizeNodeIds($getRoot());
+		});
+		editor.setEditorState(editorState);
 	}
 	write(editor, options) {
 		if (options?.selection) return editor.getEditorState().read(() => {
@@ -4901,6 +5358,7 @@ const LitexmlPlugin = class extends KernelPlugin {
 		if (config?.enabled !== false) kernel.registerDataSource(this.datasource);
 	}
 	onInit(editor) {
+		this.register(registerNodeIdentityPolicy(editor, liteXmlIdentityPolicy));
 		this.register(registerLiteXMLCommand(editor, this.datasource));
 		this.register(registerLiteXMLDiffCommand(editor));
 		this.register(registerLegacyTableCellDiffNormalization(editor));
@@ -4940,6 +5398,7 @@ const LitexmlPlugin = class extends KernelPlugin {
 					diffNode.getChildren().forEach((child) => nodeToXML(child, lines, indent));
 					break;
 				case "remove": break;
+				case "listItemRemove": break;
 				case "listItemModify": diffNode.getChildAtIndex(1).getChildren().forEach((child) => {
 					nodeToXML(child, lines, indent);
 				});
@@ -4992,6 +5451,7 @@ const LitexmlPlugin = class extends KernelPlugin {
 					diffNode.getChildren().forEach((child) => ctx.processChild(ctx, child));
 					break;
 				case "remove": break;
+				case "listItemRemove": break;
 				case "listItemModify": diffNode.getChildAtIndex(1).getChildren().forEach((child) => {
 					ctx.processChild(ctx, child);
 				});
@@ -5004,9 +5464,32 @@ const LitexmlPlugin = class extends KernelPlugin {
 //#region src/plugins/common/data-source/json-data-source.ts
 var JSONDataSource = class extends DataSource {
 	read(editor, data, options = {}) {
-		let dataObj;
-		if (typeof data === "string") dataObj = JSON.parse(data);
-		else dataObj = data;
+		let inputData;
+		if (typeof data === "string") inputData = JSON.parse(data);
+		else inputData = data;
+		const dataObj = structuredClone(inputData);
+		if (!(options.keepId ?? dataObj.keepId ?? false)) {
+			const stripNodeIds = (node) => {
+				delete node.id;
+				const state = node.$;
+				if (state && typeof state === "object" && state.properties) {
+					const properties = { ...state.properties };
+					delete properties.nodeId;
+					if (Object.keys(properties).length > 0) node.$ = {
+						...state,
+						properties
+					};
+					else {
+						const nextState = { ...state };
+						delete nextState.properties;
+						if (Object.keys(nextState).length > 0) node.$ = nextState;
+						else delete node.$;
+					}
+				}
+				if (Array.isArray(node.children)) node.children.forEach((child) => stripNodeIds(child));
+			};
+			stripNodeIds(dataObj.root);
+		} else migrateSerializedNodeIds(dataObj.root);
 		const process = (node) => {
 			for (let i = 0; i < node.children.length; i++) {
 				const child = node.children[i];
@@ -5028,24 +5511,10 @@ var JSONDataSource = class extends DataSource {
 			}
 		};
 		process(dataObj.root);
-		if (dataObj.keepId || options.keepId) {
-			const state = editor.parseEditorState({ root: INodeHelper.createRootNode() }, (state) => {
-				try {
-					const root = $parseSerializedNodeImpl(dataObj.root, editor, true, state);
-					let maxId = -1;
-					Array.from(state._nodeMap.keys()).forEach((key) => {
-						if (key === "root") return;
-						const numericKey = Number(key);
-						if (Number.isInteger(numericKey) && numericKey >= 0) maxId = Math.max(maxId, numericKey);
-					});
-					resetRandomKey(maxId + 1);
-					state._nodeMap.set(root.getKey(), root);
-				} catch (error) {
-					console.error(error);
-				}
-			});
-			editor.setEditorState(state);
-		} else editor.setEditorState(editor.parseEditorState({ root: dataObj.root }));
+		const editorState = editor.parseEditorState({ root: dataObj.root }, () => {
+			$normalizeNodeIds($getRoot());
+		});
+		editor.setEditorState(editorState);
 	}
 	write(editor, options) {
 		if (options?.selection) return editor.getEditorState().read(() => {
@@ -5139,7 +5608,10 @@ var TextDataSource = class extends DataSource {
 			}
 			INodeHelper.appendChild(rootNode, paragraph);
 		});
-		editor.setEditorState(editor.parseEditorState({ root: rootNode }));
+		const editorState = editor.parseEditorState({ root: rootNode }, () => {
+			$normalizeNodeIds($getRoot());
+		});
+		editor.setEditorState(editorState);
 	}
 	write(editor, options) {
 		if (options?.selection) return editor.getEditorState().read(() => {
@@ -5954,6 +6426,7 @@ const CommonPlugin = class extends KernelPlugin {
 		super();
 		this.kernel = kernel;
 		this.config = config;
+		this.identityService = new NodeIdentityService();
 		this.formats = {
 			bold: true,
 			header: true,
@@ -5963,6 +6436,7 @@ const CommonPlugin = class extends KernelPlugin {
 			subscript: false,
 			superscript: false
 		};
+		kernel.registerService(INodeIdentityService, this.identityService);
 		const markdownOption = config.markdownOption ?? true;
 		if (typeof markdownOption === "object") {
 			this.formats.bold = markdownOption.bold ?? true;
@@ -6103,6 +6577,15 @@ const CommonPlugin = class extends KernelPlugin {
 		});
 		markdownService.registerMarkdownWriter("text", (ctx, node) => {
 			if (!$isTextNode(node)) return;
+			let parentNode = node.getParent();
+			let isInTableCell = false;
+			while (parentNode) {
+				if (parentNode.getType() === "tablecell" || parentNode.getType() === "table-cell-diff") {
+					isInTableCell = true;
+					break;
+				}
+				parentNode = parentNode.getParent();
+			}
 			const isBold = formats.bold && node.hasFormat("bold");
 			const isItalic = formats.italic && node.hasFormat("italic");
 			const isUnderline = node.hasFormat("underline");
@@ -6121,7 +6604,8 @@ const CommonPlugin = class extends KernelPlugin {
 			if (res) tailSpace = res[0];
 			const append = textContent.trimEnd();
 			const lastChar = append.at(-1);
-			ctx.appendLine(append);
+			const markdownText = isInTableCell ? append.replaceAll("\\", "\\\\").replaceAll("|", "\\|") : append;
+			ctx.appendLine(markdownText);
 			if (isSubscript) ctx.appendLine("~");
 			if (isSuperscript) ctx.appendLine("^");
 			if (isUnderline) ctx.appendLine("</ins>");
@@ -6137,6 +6621,16 @@ const CommonPlugin = class extends KernelPlugin {
 		registerMDReader(markdownService);
 	}
 	onInit(editor) {
+		this.register(this.identityService.bindEditor(editor));
+		this.register(editor.registerNodeTransform(RootNode, $normalizeNodeIds));
+		this.register(editor.registerCommand(SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, ({ nodes }) => {
+			const clearCopiedIds = (node) => {
+				$clearNodeId(node);
+				if ($isElementNode(node)) node.getChildren().forEach(clearCopiedIds);
+			};
+			nodes.forEach(clearCopiedIds);
+			return false;
+		}, COMMAND_PRIORITY_CRITICAL));
 		this.register(this.kernel.registerHighCommand(PASTE_COMMAND, (event) => {
 			if (!(event instanceof ClipboardEvent)) return false;
 			const clipboardData = event.clipboardData;
@@ -9971,7 +10465,11 @@ const ListPlugin = class extends KernelPlugin {
 			return false;
 		});
 		litexmlService.registerXMLWriter(ListItemNode.getType(), (node, ctx) => {
-			if ($isListItemNode(node)) return ctx.createXmlNode("li");
+			if ($isListItemNode(node)) {
+				const child = node.getFirstChild();
+				if (child?.getType() === "diff" && "diffType" in child && child.diffType === "listItemRemove") return { lines: [] };
+				return ctx.createXmlNode("li");
+			}
 			return false;
 		});
 		litexmlService.registerXMLReader("ol", (xmlNode, children) => {
@@ -10045,6 +10543,8 @@ const ListPlugin = class extends KernelPlugin {
 		markdownService.registerMarkdownWriter(ListItemNode.getType(), (ctx, node) => {
 			const parent = node.getParent();
 			if ($isListItemNode(node) && $isListNode(parent)) {
+				const child = node.getFirstChild();
+				if (child?.getType() === "diff" && "diffType" in child && child.diffType === "listItemRemove") return true;
 				if ($isListNode(node.getFirstChild())) return;
 				const level = getLevel(parent);
 				const prefix = "    ".repeat(level);
@@ -10347,14 +10847,14 @@ const MathPlugin = class extends KernelPlugin {
 		if (!litexmlService) return;
 		litexmlService.registerXMLWriter(MathInlineNode.getType(), (node, ctx) => {
 			if (node instanceof MathInlineNode) {
-				const attributes = { code: node.getTextContent() };
+				const attributes = { code: node.code };
 				return ctx.createXmlNode("math", attributes);
 			}
 			return false;
 		});
 		litexmlService.registerXMLWriter(MathBlockNode.getType(), (node, ctx) => {
 			if (node instanceof MathBlockNode) {
-				const attributes = { code: node.getTextContent() };
+				const attributes = { code: node.code };
 				return ctx.createXmlNode("mathBlock", attributes);
 			}
 			return false;
@@ -11822,24 +12322,10 @@ const extractMediaFromEditorState = (state) => {
 };
 //#endregion
 //#region src/headless/index.ts
-const getNumericId = (id) => {
-	if (typeof id !== "number" && typeof id !== "string") return null;
-	const numericId = Number(id);
-	return Number.isInteger(numericId) && numericId >= 0 ? numericId : null;
-};
-const findMaxSerializedId = (node) => {
-	if (!node || typeof node !== "object") return -1;
-	const record = node;
-	const ownMax = getNumericId(record.id) ?? -1;
-	if (!Array.isArray(record.children)) return ownMax;
-	return record.children.reduce((maxId, child) => Math.max(maxId, findMaxSerializedId(child)), ownMax);
-};
-const createSerializedId = (context) => String(context.nextId++);
-const createCodeChildrenFromLegacyCode = (code, context) => code.split("\n").flatMap((text, index, array) => {
+const createCodeChildrenFromLegacyCode = (code) => code.split("\n").flatMap((text, index, array) => {
 	const textNode = {
 		detail: 0,
 		format: 0,
-		id: createSerializedId(context),
 		mode: "normal",
 		style: "",
 		text,
@@ -11848,18 +12334,17 @@ const createCodeChildrenFromLegacyCode = (code, context) => code.split("\n").fla
 	};
 	if (index === array.length - 1) return textNode;
 	return [textNode, {
-		id: createSerializedId(context),
 		type: "linebreak",
 		version: 1
 	}];
 });
-const normalizeLegacyEditorDataNode = (node, context) => {
+const normalizeLegacyEditorDataNode = (node) => {
 	if (!node || typeof node !== "object") return node;
 	const record = node;
-	const children = Array.isArray(record.children) ? record.children.map((child) => normalizeLegacyEditorDataNode(child, context)) : record.children;
+	const children = Array.isArray(record.children) ? record.children.map((child) => normalizeLegacyEditorDataNode(child)) : record.children;
 	if (record.type === "code" && typeof record.code === "string" && !Array.isArray(children)) return {
 		...record,
-		children: createCodeChildrenFromLegacyCode(record.code, context),
+		children: createCodeChildrenFromLegacyCode(record.code),
 		direction: record.direction ?? "ltr",
 		format: record.format ?? "",
 		indent: record.indent ?? 0,
@@ -11874,10 +12359,9 @@ const normalizeLegacyEditorDataNode = (node, context) => {
 };
 const normalizeLegacyEditorData = (editorData) => {
 	const data = typeof editorData === "string" ? JSON.parse(editorData) : editorData;
-	const context = { nextId: findMaxSerializedId(data.root) + 1 };
 	return {
 		...data,
-		root: normalizeLegacyEditorDataNode(data.root, context)
+		root: normalizeLegacyEditorDataNode(data.root)
 	};
 };
 const extractSerializedCodeText = (children) => children.map((child) => {
@@ -11960,6 +12444,17 @@ var HeadlessEditor = class {
 		await moment();
 		return this;
 	}
+	async applyLiteXMLBatchWithResults(operations) {
+		let results;
+		if (!this.kernel.dispatchCommand(LITEXML_MODIFY_WITH_RESULTS_COMMAND, {
+			onResults: (operationResults) => {
+				results = operationResults;
+			},
+			operations
+		}) || !results) throw new Error("LiteXML batch result command is not registered.");
+		await moment();
+		return results;
+	}
 	export(options = {}) {
 		const snapshot = {
 			editorData: preserveSerializedCodeTextInEditorData(this.kernel.getDocument("json")),
@@ -12002,4 +12497,4 @@ function createHeadlessEditor(options) {
 	return new HeadlessEditor(options);
 }
 //#endregion
-export { DEFAULT_HEADLESS_EDITOR_PLUGINS, HeadlessEditor, createHeadlessEditor, extractMediaFromEditorState };
+export { $getNodeById, $getNodeId, DEFAULT_HEADLESS_EDITOR_PLUGINS, HeadlessEditor, INodeIdentityService, createHeadlessEditor, extractMediaFromEditorState };