@lobehub/editor 4.8.5 → 4.9.0

package/es/index.js

@@ -1,20 +1,20 @@
-import { $ as DOM_TEXT_TYPE, A as $createCodeMirrorNode, At as createDebugLogger, C as $createCodeNode$1, Ct as CONTROL_OR_META, Dt as KeyEnum, E as CodeNode$1, Et as HotkeyScopeEnum, F as $isCursorNode, Ft as init_debug, G as kernel_exports, Gt as INodeHelper, H as DataSource, I as CardLikeElementNode, It as prodSafeLogger, J as $getNearestNodeFromDOMNode, K as $closest, Kt as init_helper, M as CodeMirrorNode, Mt as debugLoggers, N as $createCursorNode, Nt as debug_exports, Ot as init_hotkey, P as $isCardLikeElementNode, Pt as devConsole, Q as DOM_ELEMENT_TYPE, R as cursorNodeSerialized, S as formatUrl, St as init_registerHotkey, Tt as HotkeyEnum, U as Kernel, V as resetRandomKey, W as init_kernel, X as DOM_DOCUMENT_FRAGMENT_TYPE, Y as $getNodeFromDOMNode, Yt as __toCommonJS, Z as DOM_DOCUMENT_TYPE, _ as AutoLinkNode, _t as unregisterEditorKernel, a as $createMathBlockNode, at as generateEditorId, b as LinkNode, bt as HOVER_COMMAND, c as MathBlockNode, ct as getNodeKeyFromDOMNode, dt as isDOMNode, et as EDITOR_THEME_KEY, f as LinkHighlightNode, ft as isDocumentFragment, g as $toggleLink, gt as registerEditorKernel, h as $isLinkNode, ht as reconcileDecorator, it as genServiceId, j as $isCodeMirrorNode, jt as debugLogger, kt as browserDebug, l as MathInlineNode, lt as getParentElement, m as $createLinkNode, mt as noop, nt as compareNodeOrder, o as $createMathInlineNode, ot as getKernelFromEditor, pt as moment, q as $closestNodeType, rt as createEmptyEditorState, s as $isMathNode, st as getKernelFromEditorConfig, tt as assert, u as $createLinkHighlightNode, ut as init_utils, v as HOVER_LINK_COMMAND, vt as KernelPlugin, wt as init_sys, x as TOGGLE_LINK_COMMAND, xt as getHotkeyById, y as HOVER_OUT_LINK_COMMAND, yt as init_plugin } from "./style-Tlcvrhqp.js";
-import { A as idToChar, B as MARKDOWN_READER_LEVEL_NORMAL, C as ReactEditorContent, D as $cloneNode, E as LitexmlService, F as MarkdownPlugin, G as INSERT_MARKDOWN_COMMAND, H as INodePlugin, I as detectCodeLanguage, J as ReactEditor, K as isPunctuationChar, L as detectLanguage, M as INSERT_QUOTE_COMMAND, N as ReactMarkdownPlugin, O as $parseSerializedNodeImpl, P as useTranslation, R as IMarkdownShortCutService, S as ReactPlainText, T as ILitexmlService, U as INodeService, V as MARKDOWN_WRITER_LEVEL_MAX, W as GET_MARKDOWN_SELECTION_COMMAND, X as LexicalErrorBoundary, Y as useLexicalComposerContext, _ as bundledLanguagesInfo, a as ReactMentionPlugin, b as INSERT_CODEINLINE_COMMAND, c as INSERT_CHECK_LIST_COMMAND, d as registerLinkHighlightCommand, f as extractUrlFromText, g as useLexicalNodeSelection, i as SlashPlugin, j as INSERT_HEADING_COMMAND, k as charToId, l as registerCheckList, m as sanitizeUrl, n as ReactSlashOption, o as MentionPlugin, p as getSelectedNode, q as useLexicalEditor, r as SlashMenu, s as INSERT_MENTION_COMMAND, t as ReactSlashPlugin, u as INSERT_LINK_HIGHLIGHT_COMMAND, v as CodeblockPlugin, w as CommonPlugin, x as registerCodeInlineCommand, y as UPDATE_CODEBLOCK_LANG, z as MARKDOWN_READER_LEVEL_HIGH } from "./ReactSlashPlugin-BZvB0g1k.js";
-import { S as PlaceholderNode, _ as $isFileNode, a as styles$16, b as DiffNode, c as ImageNode, d as BlockImageNode, f as $createHorizontalRuleNode, g as $createFileNode, h as styles$15, i as imageBroken, l as $createBlockImageNode, m as HorizontalRuleNode, n as styles$18, o as $createImageNode, p as $isHorizontalRuleNode, r as styles$17, s as $isImageNode, t as styles$19, u as $isBlockImageNode, v as FileNode, x as PlaceholderBlockNode, y as $createDiffNode } from "./style-B7Vfm0cE.js";
+import { $ as DOM_TEXT_TYPE, A as $createCodeMirrorNode, At as createDebugLogger, B as Editor, C as $createCodeNode$1, Ct as CONTROL_OR_META, Dt as KeyEnum, E as CodeNode$1, Et as HotkeyScopeEnum, F as $isCursorNode, Ft as init_debug, G as kernel_exports, Gt as INodeHelper, H as DataSource, I as CardLikeElementNode, It as prodSafeLogger, J as $getNearestNodeFromDOMNode, K as $closest, Kt as init_helper, M as CodeMirrorNode, Mt as debugLoggers, N as $createCursorNode, Nt as debug_exports, Ot as init_hotkey, P as $isCardLikeElementNode, Pt as devConsole, Q as DOM_ELEMENT_TYPE, R as cursorNodeSerialized, S as formatUrl, St as init_registerHotkey, Tt as HotkeyEnum, U as Kernel, V as resetRandomKey, W as init_kernel, X as DOM_DOCUMENT_FRAGMENT_TYPE, Y as $getNodeFromDOMNode, Yt as __toCommonJS, Z as DOM_DOCUMENT_TYPE, _ as AutoLinkNode, _t as unregisterEditorKernel, a as $createMathBlockNode, at as generateEditorId, b as LinkNode, bt as HOVER_COMMAND, c as MathBlockNode, ct as getNodeKeyFromDOMNode, dt as isDOMNode, et as EDITOR_THEME_KEY, f as LinkHighlightNode, ft as isDocumentFragment, g as $toggleLink, gt as registerEditorKernel, h as $isLinkNode, ht as reconcileDecorator, it as genServiceId, j as $isCodeMirrorNode, jt as debugLogger, kt as browserDebug, l as MathInlineNode, lt as getParentElement, m as $createLinkNode, mt as noop, nt as compareNodeOrder, o as $createMathInlineNode, ot as getKernelFromEditor, pt as moment, q as $closestNodeType, rt as createEmptyEditorState, s as $isMathNode, st as getKernelFromEditorConfig, tt as assert, u as $createLinkHighlightNode, ut as init_utils, v as HOVER_LINK_COMMAND, vt as KernelPlugin, wt as init_sys, x as TOGGLE_LINK_COMMAND, xt as getHotkeyById, y as HOVER_OUT_LINK_COMMAND, yt as init_plugin } from "./style-DAKdXzC4.js";
+import { A as detectLanguage, B as INodePlugin, C as ReactPlainText, D as useTranslation, E as ReactMarkdownPlugin, F as GET_MARKDOWN_SELECTION_COMMAND, G as idToChar, H as $cloneNode, I as INSERT_MARKDOWN_COMMAND, J as useLexicalEditor, K as INSERT_HEADING_COMMAND, L as isPunctuationChar, M as MARKDOWN_READER_LEVEL_HIGH, N as MARKDOWN_READER_LEVEL_NORMAL, O as MarkdownPlugin, P as MARKDOWN_WRITER_LEVEL_MAX, R as ILitexmlService, S as registerCodeInlineCommand, T as CommonPlugin, U as $parseSerializedNodeImpl, V as INodeService, W as charToId, X as useLexicalComposerContext, Y as ReactEditor, Z as LexicalErrorBoundary, _ as UPDATE_CODEBLOCK_LANG, a as ReactMentionPlugin, b as registerCheckList, c as INSERT_LINK_HIGHLIGHT_COMMAND, d as getSelectedNode, f as sanitizeUrl, g as CodeblockPlugin, h as bundledLanguagesInfo, i as SlashPlugin, j as IMarkdownShortCutService, k as detectCodeLanguage, l as registerLinkHighlightCommand, m as useLexicalNodeSelection, n as ReactSlashOption, o as MentionPlugin, q as INSERT_QUOTE_COMMAND, r as SlashMenu, s as INSERT_MENTION_COMMAND, t as ReactSlashPlugin, u as extractUrlFromText, v as getCodeLanguageByInput, w as ReactEditorContent, x as INSERT_CODEINLINE_COMMAND, y as INSERT_CHECK_LIST_COMMAND, z as LitexmlService } from "./ReactSlashPlugin-Dn5VWUzS.js";
+import { S as DiffNode, _ as PlaceholderNode, a as styles$16, b as HorizontalRuleNode, c as ImageNode, d as BlockImageNode, f as styles$15, g as PlaceholderBlockNode, h as FileNode, i as imageBroken, l as $createBlockImageNode, m as $isFileNode, n as styles$18, o as $createImageNode, p as $createFileNode, r as styles$17, s as $isImageNode, t as styles$19, u as $isBlockImageNode, v as $createHorizontalRuleNode, x as $createDiffNode, y as $isHorizontalRuleNode } from "./style-CcDKrOoJ.js";
 import { $computeTableMapSkipCellCheck, $createTableNodeWithDimensions, $createTableSelection, $deleteTableColumnAtSelection, $deleteTableRowAtSelection, $findTableNode, $getElementForTableNode, $getNodeTriplet, $getTableAndElementByKey, $getTableCellNodeFromLexicalNode, $getTableColumnIndexFromTableCellNode, $getTableNodeFromLexicalNodeOrThrow, $getTableRowIndexFromTableCellNode, $insertTableColumnAtSelection, $insertTableRowAtSelection, $isTableCellNode, $isTableNode, $isTableRowNode, $isTableSelection, $mergeCells, $unmergeCell, TableCellHeaderStates, TableCellNode, TableNode, TableNode as TableNode$1, TableRowNode, getDOMCellFromTarget, getTableElement, getTableObserverFromTableElement, registerTableCellUnmergeTransform, registerTablePlugin, registerTableSelectionObserver, setScrollableTablesActive } from "@lexical/table";
 import { debounce } from "es-toolkit/compat";
 import EventEmitter from "eventemitter3";
-import { $createNodeSelection, $createParagraphNode, $createRangeSelection, $createTextNode, $getNearestNodeFromDOMNode as $getNearestNodeFromDOMNode$1, $getNodeByKey, $getPreviousSelection, $getRoot, $getSelection, $insertNodes, $isBlockElementNode, $isDecoratorNode, $isElementNode, $isNodeSelection, $isRangeSelection, $isRootNode, $isRootOrShadowRoot, $isTextNode, $nodesOfType, $normalizeSelection__EXPERIMENTAL, $setSelection, CLICK_COMMAND, COMMAND_PRIORITY_CRITICAL, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_HIGH, COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, DROP_COMMAND, HISTORY_MERGE_TAG, INDENT_CONTENT_COMMAND, INSERT_TAB_COMMAND, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, KEY_DOWN_COMMAND, KEY_ESCAPE_COMMAND, KEY_TAB_COMMAND, OUTDENT_CONTENT_COMMAND, PASTE_COMMAND, ParagraphNode, SELECTION_CHANGE_COMMAND, SKIP_SCROLL_INTO_VIEW_TAG, TextNode, createCommand, getDOMSelection, getDOMSelectionFromTarget, isHTMLElement, isModifierMatch } from "lexical";
+import { $createNodeSelection, $createParagraphNode, $createRangeSelection, $createTextNode, $getNearestNodeFromDOMNode as $getNearestNodeFromDOMNode$1, $getNodeByKey, $getPreviousSelection, $getRoot, $getSelection, $insertNodes, $isBlockElementNode, $isDecoratorNode, $isElementNode, $isNodeSelection, $isRangeSelection, $isRootNode, $isRootOrShadowRoot, $isTextNode, $nodesOfType, $normalizeSelection__EXPERIMENTAL, $setSelection, CLICK_COMMAND, COMMAND_PRIORITY_CRITICAL, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_HIGH, COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, DROP_COMMAND, HISTORY_MERGE_TAG, INDENT_CONTENT_COMMAND, INSERT_TAB_COMMAND, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, KEY_DOWN_COMMAND, KEY_ESCAPE_COMMAND, KEY_TAB_COMMAND, OUTDENT_CONTENT_COMMAND, PASTE_COMMAND, ParagraphNode, SELECTION_CHANGE_COMMAND, SKIP_SCROLL_INTO_VIEW_TAG, TabNode, TextNode, createCommand, getDOMSelection, getDOMSelectionFromTarget, isHTMLElement, isModifierMatch } from "lexical";
 import { DRAG_DROP_PASTE } from "@lexical/rich-text";
 import { $filter, $findMatchingParent, $getNearestBlockElementAncestorOrThrow, $getNearestNodeOfType, $insertNodeToNearestRoot, $wrapNodeInElement, addClassNamesToElement, calculateZoomLevel, mergeRegister, removeClassNamesFromElement } from "@lexical/utils";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { Suspense, forwardRef, memo, useCallback, useEffect, useImperativeHandle, useLayoutEffect, useMemo, useRef, useState } from "react";
-import { ActionIcon, ActionIconGroup, Block, Button, Center, Dropdown, Flexbox, Hotkey, Icon, Input, InputNumber, LOBE_THEME_APP_ID, MaterialFileTypeIcon, Popover, Select, Text, TextArea } from "@lobehub/ui";
-import katex, { renderToString } from "katex";
-import "@lexical/code-core";
-import { createStaticStyles, cssVar, cx, useThemeMode } from "antd-style";
 import { $createListItemNode, $createListNode, $isListItemNode, $isListNode, INSERT_ORDERED_LIST_COMMAND, INSERT_ORDERED_LIST_COMMAND as INSERT_ORDERED_LIST_COMMAND$1, INSERT_UNORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND as INSERT_UNORDERED_LIST_COMMAND$1, ListItemNode, ListNode, REMOVE_LIST_COMMAND, UPDATE_LIST_START_COMMAND, registerList, registerListStrictIndentTransform } from "@lexical/list";
 import { DOMParser } from "@xmldom/xmldom";
+import katex, { renderToString } from "katex";
+import { $isCodeHighlightNode, $isCodeNode, CodeHighlightNode, CodeNode } from "@lexical/code-core";
+import { ActionIcon, ActionIconGroup, Block, Button, Center, Dropdown, Flexbox, Hotkey, Icon, Input, InputNumber, LOBE_THEME_APP_ID, MaterialFileTypeIcon, Popover, Select, Text, TextArea } from "@lobehub/ui";
+import { createStaticStyles, cssVar, cx, useThemeMode } from "antd-style";
 import { BaselineIcon, Check, ChevronDown, ChevronRight, CopyIcon, EditIcon, ExternalLinkIcon, Grid2X2XIcon, LinkIcon, LoaderCircleIcon, MoreHorizontalIcon, PanelBottomCloseIcon, PanelLeftCloseIcon, PanelRightCloseIcon, PanelTopCloseIcon, PlusIcon, TableColumnsSplitIcon, TableRowsSplitIcon, UnlinkIcon, UploadIcon, X } from "lucide-react";
 import { createPortal } from "react-dom";
 import { Switch, message } from "antd";
@@ -41,1121 +41,813 @@ const LexicalPortalContainer = forwardRef(({ editor, node, children }, ref) => {
 });
 LexicalPortalContainer.displayName = "LexicalPortalContainer";
 //#endregion
-//#region src/plugins/inode/react/index.tsx
-const ReactNodePlugin = () => {
-	const [editor] = useLexicalComposerContext();
-	useLayoutEffect(() => {
-		editor.registerPlugin(INodePlugin);
-	}, [editor]);
-	return null;
-};
-ReactNodePlugin.displayName = "ReactNodePlugin";
-//#endregion
-//#region src/utils/url.ts
-init_debug();
+//#region src/plugins/litexml/command/index.ts
+init_helper();
 init_hotkey();
-init_registerHotkey();
-/**
-* Shared URL validation utilities
-*/
-const URL_REGEX = /* @__PURE__ */ new RegExp(/^(?:(?:https?|ftp):\/\/)?(?:www\.)?[\dA-Za-z][\w#%+./:=?@~-]*[\w#%+/=@~-]$/);
-/**
-* Validates if a string is a valid URL
-* @param url - The URL to validate
-* @returns true if the URL is valid, false otherwise
-*/
-function isValidUrl(url) {
-	if (!url || typeof url !== "string") return false;
-	const trimmed = url.trim();
-	if (URL_REGEX.test(trimmed)) return true;
-	try {
-		const urlObj = new URL(trimmed);
-		return !!urlObj.protocol && !!urlObj.hostname;
-	} catch {}
-	if (/^[\da-z][\w#%+./:=?@~-]*\.[\w#%+/:=?@~-]+$/i.test(trimmed)) return true;
-	return false;
+init_plugin();
+init_debug();
+const logger$6 = createDebugLogger("plugin", "litexml");
+function toArrayXml(litexml) {
+	return Array.isArray(litexml) ? litexml : [litexml];
 }
-/**
-* Checks if text is a pure URL (single URL without other text)
-* @param text - The text to check
-* @returns true if text is a pure URL, false otherwise
-*/
-function isPureUrl(text) {
-	if (!text || typeof text !== "string") return false;
-	const trimmed = text.trim();
-	if (trimmed.includes("\n")) return false;
-	return isValidUrl(trimmed);
+function tryParseChild(child, editor) {
+	try {
+		const oldNode = $getNodeByKey(child.id);
+		return {
+			newNode: $parseSerializedNodeImpl(child, editor),
+			oldNode
+		};
+	} catch (error) {
+		logger$6.error("❌ Error parsing child node:", error);
+		return {
+			newNode: null,
+			oldNode: null
+		};
+	}
 }
-//#endregion
-//#region src/plugins/auto-complete/plugin/index.ts
-init_helper();
-init_plugin();
-const AutoCompletePlugin = class extends KernelPlugin {
-	static {
-		this.pluginName = "AutoCompletePlugin";
+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);
+		return;
 	}
-	constructor(kernel, config) {
-		super();
-		this.kernel = kernel;
-		this.config = config;
-		this.logger = createDebugLogger("plugin", "auto-complete");
-		this.lastCursorPosition = null;
-		this.cursorStableTimer = null;
-		this.abortController = null;
-		this.placeholderNodes = [];
-		this.currentSuggestion = null;
-		this.markdownService = null;
-		this.delay = config?.delay ?? 1e3;
-		kernel.registerNodes([PlaceholderNode, PlaceholderBlockNode]);
-		if (config?.theme) kernel.registerThemes(config?.theme);
+	if (oldNode === oldBlock) {
+		const diffNode = $createDiffNode("modify");
+		diffNode.append($cloneNode(oldBlock, editor), newNode);
+		oldNode.replace(diffNode, false);
+	} else {
+		if (!modifyBlockNodes.has(oldBlock.getKey())) {
+			modifyBlockNodes.add(oldBlock.getKey());
+			const diffNode = $createDiffNode("modify");
+			diffNode.append($cloneNode(oldBlock, editor));
+			diffNodeMap.set(oldBlock.getKey(), diffNode);
+		}
+		oldNode.replace(newNode, false);
 	}
-	onInit(editor) {
-		this.markdownService = this.kernel.requireService(IMarkdownShortCutService);
-		if (!this.markdownService) {
-			this.logger.error("❌ MarkdownShortCutService is required for AutoCompletePlugin");
-			return;
+}
+function finalizeModifyBlocks(modifyBlockNodes, diffNodeMap, editor) {
+	for (const blockNodeKey of modifyBlockNodes) {
+		const blockNode = $getNodeByKey(blockNodeKey);
+		const diffNode = diffNodeMap.get(blockNodeKey);
+		if (diffNode && blockNode) if (blockNode.getType() === "listitem" && $isElementNode(blockNode)) {
+			const newDiffNode = $createDiffNode("listItemModify");
+			const firstChild = diffNode.getFirstChild();
+			if (firstChild && $isElementNode(firstChild)) newDiffNode.append(firstChild);
+			const children = blockNode.getChildren();
+			const p = $createParagraphNode();
+			children.forEach((child) => {
+				child.remove();
+				p.append(child);
+			});
+			newDiffNode.append(p);
+			blockNode.append(newDiffNode);
+			continue;
+		} else {
+			diffNode.append($cloneNode(blockNode, editor));
+			blockNode.replace(diffNode, false);
 		}
-		this.register(editor.registerUpdateListener(({ editorState }) => {
-			editorState.read(() => {
-				if (editor.isComposing()) return;
-				const selection = $getSelection();
-				if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
-					this.clearTimer();
-					this.clearPlaceholderNodes(editor);
-					return;
-				}
-				const currentPosition = {
-					key: selection.anchor.key,
-					offset: selection.anchor.offset,
-					type: selection.anchor.type
-				};
-				if (this.hasPositionChanged(currentPosition)) {
-					this.clearTimer();
-					this.clearPlaceholderNodes(editor);
-					this.abortController = new AbortController();
-					this.cursorStableTimer = window.setTimeout(() => {
-						this.handleCursorStable(editor, currentPosition);
-					}, this.delay);
+	}
+}
+/**
+* Wrap a block-level change with a `modify` diff: clone the old block, run the
+* provided changeFn (which should mutate nodes inside the block), then clone
+* the new block and replace it with the diff node. Useful for inline->block
+* transitions where we want to show a modify diff.
+*/
+function wrapBlockModify(oldBlock, editor, changeFn) {
+	if ($isListItemNode(oldBlock)) {
+		const diffNode = $createDiffNode("listItemModify");
+		const p = $createParagraphNode();
+		oldBlock.getChildren().forEach((child) => {
+			p.append($cloneNode(child, editor));
+		});
+		changeFn();
+		diffNode.append(p);
+		const pNew = $createParagraphNode();
+		oldBlock.getChildren().forEach((child) => {
+			pNew.append(child);
+		});
+		diffNode.append(pNew);
+		oldBlock.append(diffNode);
+		return;
+	}
+	const diffNode = $createDiffNode("modify");
+	diffNode.append($cloneNode(oldBlock, editor));
+	changeFn();
+	const newBlock = $getNodeByKey(oldBlock.getKey());
+	if (!newBlock) throw new Error("New block node not found for modify wrapper.");
+	diffNode.append($cloneNode(newBlock, editor));
+	newBlock.replace(diffNode, false);
+}
+const LITEXML_MODIFY_COMMAND = createCommand("LITEXML_MODIFY_COMMAND");
+const LITEXML_APPLY_COMMAND = createCommand("LITEXML_APPLY_COMMAND");
+const LITEXML_REMOVE_COMMAND = createCommand("LITEXML_REMOVE_COMMAND");
+const LITEXML_INSERT_COMMAND = createCommand("LITEXML_INSERT_COMMAND");
+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;
+		}, []);
+		try {
+			resultPayload.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$6.warn(`⚠️ Unknown action type: ${action}`);
 				}
 			});
-		}));
-		this.register(editor.registerCommand(KEY_TAB_COMMAND, (event) => {
-			if (this.currentSuggestion) {
-				event?.preventDefault();
-				this.applySuggestion(editor);
-				return true;
-			}
 			return false;
-		}, COMMAND_PRIORITY_HIGH));
-		this.register(editor.registerCommand(KEY_ESCAPE_COMMAND, (event) => {
-			if (this.currentSuggestion) {
-				event?.preventDefault();
-				this.clearPlaceholderNodes(editor);
-				this.currentSuggestion = null;
-				return true;
-			}
+		} catch (error) {
+			logger$6.error("❌ Error processing LITEXML_MODIFY_COMMAND:", error);
 			return false;
-		}, COMMAND_PRIORITY_CRITICAL));
-		this.register(editor.registerTextContentListener(() => {
-			if (this.placeholderNodes.length > 0) this.clearPlaceholderNodes(editor);
-		}));
-	}
-	hasPositionChanged(currentPosition) {
-		if (!this.lastCursorPosition) return true;
-		return this.lastCursorPosition.key !== currentPosition.key || this.lastCursorPosition.offset !== currentPosition.offset || this.lastCursorPosition.type !== currentPosition.type;
-	}
-	clearTimer() {
-		this.abortController?.abort("use cancel");
-		if (this.cursorStableTimer) {
-			clearTimeout(this.cursorStableTimer);
-			this.cursorStableTimer = null;
 		}
-	}
-	handleCursorStable(editor, position) {
-		editor.getEditorState().read(() => {
-			if (editor.isComposing()) return;
-			if (!this.abortController || this.abortController.signal.aborted) return;
-			const selection = $getSelection();
-			if (!$isRangeSelection(selection) || !selection.isCollapsed()) return;
-			const currentPosition = {
-				key: selection.anchor.key,
-				offset: selection.anchor.offset,
-				type: selection.anchor.type
-			};
-			if (!this.isSamePosition(position, currentPosition)) return;
-			if (this.lastCursorPosition && this.isSamePosition(position, this.lastCursorPosition)) return;
-			this.lastCursorPosition = currentPosition;
-			const anchorNode = selection.anchor.getNode();
-			let selectionType = "unknown";
-			const textRet = this.getTextBeforeCursor(selection);
-			selectionType = anchorNode.getType();
-			if (this.config?.onAutoComplete) this.config.onAutoComplete({
-				abortSignal: this.abortController.signal,
-				afterText: textRet.textAfter,
-				editor: this.kernel,
-				input: textRet.textBefore,
-				selectionType
-			}).then((result) => {
-				let currentSelection = null;
-				editor.getEditorState().read(() => {
-					currentSelection = $getSelection();
-				});
-				if (editor.isComposing()) {
-					this.clearPlaceholderNodes(editor);
-					return;
-				}
-				if (!currentSelection || !$isRangeSelection(currentSelection) || !currentSelection.isCollapsed()) {
-					this.clearPlaceholderNodes(editor);
-					return;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_APPLY_COMMAND, (payload) => {
+		const { litexml, delay } = payload;
+		handleModify(editor, dataSource, toArrayXml(litexml), delay);
+		return false;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_REMOVE_COMMAND, (payload) => {
+		const { id, delay } = payload;
+		handleRemove(editor, charToId(id), delay);
+		return false;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_INSERT_COMMAND, (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$6.warn(`⚠️ Node with key ${child.id} not found for diffing.`);
+				} catch (error) {
+					logger$6.error("❌ Error replacing node:", error);
 				}
-				const newPosition = {
-					key: currentSelection.anchor.key,
-					offset: currentSelection.anchor.offset,
-					type: currentSelection.anchor.type
-				};
-				if (!this.isSamePosition(currentPosition, newPosition)) {
-					this.clearPlaceholderNodes(editor);
-					return;
+			});
+		});
+		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]);
+				} catch (error) {
+					logger$6.error("❌ Error replacing node:", error);
 				}
-				if (result) {
-					this.currentSuggestion = result;
-					this.showPlaceholderNodes(editor, result);
-					this.logger.debug("🔍 Auto-complete triggered:", {
-						afterText: textRet.textAfter,
-						input: textRet.textBefore,
-						position: currentPosition,
-						result,
-						selectionType
-					});
-				} else this.clearPlaceholderNodes(editor);
 			});
 		});
-	}
-	getTextBeforeCursor(selection) {
-		const ret = {
-			textAfter: "",
-			textBefore: ""
-		};
-		const anchorNode = selection.anchor.getNode();
-		const anchorOffset = selection.anchor.offset;
-		let paragraphNode = anchorNode;
-		while (paragraphNode && paragraphNode.isInline()) {
-			const parent = paragraphNode.getParent();
-			if (!parent) break;
-			paragraphNode = parent;
+	});
+}
+function handleRemove(editor, key, delay) {
+	editor.update(() => {
+		const node = $getNodeByKey(key);
+		if (!node) return;
+		if (!delay) {
+			node.remove();
+			return;
 		}
-		if (!paragraphNode) return ret;
-		this.logger.debug("🔍 Paragraph Node Type:", paragraphNode, anchorNode);
-		let founded = false;
-		const collectTextBeforeCursor = (node, targetNode, targetOffset) => {
-			if (node === targetNode) {
-				founded = true;
-				if (node.getTextContent) {
-					const nodeText = node.getTextContent();
-					return {
-						text: nodeText.slice(0, targetOffset),
-						textAfter: nodeText.slice(targetOffset)
-					};
+		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");
+						newDiff.append(children[0]);
+						originDiffNode.replace(newDiff, false);
+						return;
+					}
+					case "listItemModify": {
+						const children = originDiffNode.getChildren();
+						originDiffNode.replace(children[0], false).selectEnd();
+						return;
+					}
+					case "remove":
+					case "unchanged": break;
 				}
-				return {
-					text: "",
-					textAfter: ""
-				};
+				return;
 			}
-			let collectedText = "";
-			let collectedTextAfter = "";
-			if (node.getTextContent && node.getType() === "text") if (founded) collectedTextAfter += node.getTextContent();
-			else collectedText += node.getTextContent();
-			if (node.getChildren) {
-				const children = node.getChildren();
-				for (const child of children) {
-					const result = collectTextBeforeCursor(child, targetNode, targetOffset);
-					collectedTextAfter += result.textAfter;
-					collectedText += result.text;
-				}
+			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);
 			}
-			return {
-				text: collectedText,
-				textAfter: collectedTextAfter
-			};
-		};
-		const result = collectTextBeforeCursor(paragraphNode, anchorNode, anchorOffset);
-		return {
-			textAfter: result.textAfter,
-			textBefore: result.text
-		};
-	}
-	showPlaceholderNodes(editor, suggestion) {
-		editor.update(() => {
-			const selection = $getSelection();
-			if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
-				this.logger.warn("⚠️ No valid selection for placeholder");
+		} 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;
 			}
-			if (!this.markdownService) {
-				this.logger.warn("⚠️ No valid markdown service for placeholder");
+			wrapBlockModify(oldBlock, editor, () => {
+				node.remove();
+			});
+		}
+	});
+}
+function handleInsert(editor, payload, dataSource) {
+	const { litexml, delay } = payload;
+	const isBefore = "beforeId" in payload;
+	const inode = dataSource.readLiteXMLToInode(litexml);
+	editor.update(() => {
+		try {
+			let referenceNode = null;
+			if (isBefore) if (payload.beforeId === "root") referenceNode = $getRoot().getFirstChild();
+			else referenceNode = $getNodeByKey(charToId(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));
+			if (!delay) {
+				if (isBefore) newNodes.reverse().forEach((node) => {
+					referenceNode = referenceNode.insertBefore(node);
+				});
+				else newNodes.forEach((node) => {
+					if (referenceNode) referenceNode = referenceNode.insertAfter(node);
+				});
 				return;
 			}
-			const nodes = this.markdownService.parseMarkdownToLexical(suggestion);
-			if (nodes.children[0]) {
-				const firstChild = nodes.children[0];
-				firstChild.children = [{
-					children: firstChild.children,
-					type: "PlaceholderInline"
-				}];
-			}
-			for (let i = 1; i < nodes.children.length; i++) {
-				const child = nodes.children[i];
-				nodes.children[i] = {
-					children: [child],
-					type: "PlaceholderBlock"
-				};
-			}
-			const markerNode = INodeHelper.createTextNode("​");
-			nodes.children.push({
-				children: [markerNode],
-				name: "",
-				type: "PlaceholderInline"
-			});
-			const saveSel = selection.clone();
-			this.markdownService.insertIRootNode(editor, nodes, selection);
-			$setSelection(saveSel);
-		});
-	}
-	clearPlaceholderNodes(editor) {
-		editor.update(() => {
-			editor.getEditorState()._nodeMap.forEach((node) => {
-				const selection = $getSelection();
-				const clonedSelection = selection ? selection.clone() : null;
-				if (node.isAttached() && ["PlaceholderBlock", "PlaceholderInline"].includes(node.getType())) {
-					if (node.getType() === "PlaceholderInline" && node.getTextContent().includes("​") && node.getPreviousSibling() === null) {
-						while (node.getNextSibling()) {
-							const next = node.getNextSibling();
-							if (next) $insertNodes([next]);
-						}
-						$setSelection(clonedSelection);
-						node.getParent()?.remove();
-						return;
+			if (isBefore) if (referenceNode.isInline() === false) {
+				const originDiffNode = $closest(referenceNode, (node) => node.getType() === DiffNode.getType());
+				if (originDiffNode) referenceNode = originDiffNode;
+				newNodes.map((node) => {
+					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) {
+				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);
 					}
-					node.remove();
-				}
+				});
+			} 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$6.error("❌ Error inserting node:", error);
+		}
+	});
+}
+//#endregion
+//#region src/plugins/litexml/command/diffCommand.ts
+let DiffAction = /* @__PURE__ */ function(DiffAction) {
+	DiffAction[DiffAction["Reject"] = 0] = "Reject";
+	DiffAction[DiffAction["Accept"] = 1] = "Accept";
+	return DiffAction;
+}({});
+const LITEXML_DIFFNODE_COMMAND = createCommand("LITEXML_DIFFNODE_COMMAND");
+const LITEXML_DIFFNODE_ALL_COMMAND = createCommand("LITEXML_DIFFNODE_ALL_COMMAND");
+function doAction(node, action) {
+	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();
+	}
+	if (node.diffType === "remove") {
+		if (action === 1) node.remove();
+		else if (action === 0) {
+			const children = node.getChildren();
+			node.replace(children[0], false).selectEnd();
+		}
+	}
+	if (node.diffType === "add") {
+		if (action === 1) {
+			const children = node.getChildren();
+			node.replace(children[0], false).selectEnd();
+		} else if (action === 0) node.remove();
+	}
+	if (node.diffType === "listItemModify") {
+		const children = node.getChildren();
+		if (action === 1) {
+			const lastChild = children[1];
+			if (!$isElementNode(lastChild)) throw new Error("Expected element node as child of DiffNode");
+			const nodeChildrens = lastChild.getChildren();
+			for (let i = nodeChildrens.length - 1; i >= 0; i--) node.insertAfter(nodeChildrens[i]);
+			const parent = node.getParentOrThrow();
+			node.remove();
+			parent.selectEnd();
+		} else if (action === 0) {
+			const firstChild = children[0];
+			if (!$isElementNode(firstChild)) throw new Error("Expected element node as child of DiffNode");
+			const nodeChildrens = firstChild.getChildren();
+			for (let i = nodeChildrens.length - 1; i >= 0; i--) node.insertAfter(nodeChildrens[i]);
+			const parent = node.getParentOrThrow();
+			node.remove();
+			parent.selectEnd();
+		}
+	}
+	if (node.diffType === "listItemRemove") {
+		if (action === 1) node.getParentOrThrow().remove();
+		else if (action === 0) {
+			node.getChildren().forEach((child) => {
+				node.getParentOrThrow().append(child);
 			});
-		});
+			node.getParentOrThrow().selectEnd();
+			node.remove();
+		}
 	}
-	applySuggestion(editor) {
-		if (!this.currentSuggestion) return;
-		const markdown = this.currentSuggestion;
+	if (node.diffType === "listItemAdd") {
+		if (action === 1) {
+			node.getChildren().forEach((child) => {
+				node.getParentOrThrow().append(child);
+			});
+			node.getParentOrThrow().selectEnd();
+			node.remove();
+		} else if (action === 0) node.remove();
+	}
+}
+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(() => {
-			const selection = $getSelection();
-			if (!$isRangeSelection(selection) || !selection.isCollapsed() || !this.markdownService) return;
-			editor.getEditorState()._nodeMap.forEach((node) => {
-				if (node.isAttached() && ["PlaceholderBlock", "PlaceholderInline"].includes(node.getType())) node.remove();
+			doAction(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());
+		});
+		if (!nodes.length) return false;
+		editor.update(() => {
+			nodes.forEach((node) => {
+				doAction(node, action);
 			});
-			const nodes = this.markdownService.parseMarkdownToLexical(markdown);
-			this.markdownService.insertIRootNode(editor, nodes, selection);
-			this.clearPlaceholderNodes(editor);
-			this.currentSuggestion = null;
 		});
-	}
-	isSamePosition(pos1, pos2) {
-		return pos1.key === pos2.key && pos1.offset === pos2.offset && pos1.type === pos2.type;
-	}
-	destroy() {
-		this.clearTimer();
-		this.placeholderNodes = [];
-		super.destroy();
-	}
-};
-//#endregion
-//#region src/plugins/auto-complete/react/style.ts
-const styles$14 = createStaticStyles(({ css }) => ({
-	placeholderBlock: css`
-    opacity: 0.4;
-  `,
-	placeholderInline: css`
-    opacity: 0.4;
-  `
-}));
+		return false;
+	}, COMMAND_PRIORITY_EDITOR));
+}
 //#endregion
-//#region src/plugins/auto-complete/react/ReactAutoCompletePlugin.tsx
-const ReactAutoCompletePlugin = ({ onAutoComplete, delay }) => {
+//#region src/plugins/inode/react/index.tsx
+const ReactNodePlugin = () => {
 	const [editor] = useLexicalComposerContext();
 	useLayoutEffect(() => {
-		editor.registerPlugin(AutoCompletePlugin, {
-			delay,
-			onAutoComplete,
-			theme: {
-				placeholderBlock: cx(styles$14.placeholderBlock),
-				placeholderInline: cx(styles$14.placeholderInline)
-			}
-		});
-	}, []);
+		editor.registerPlugin(INodePlugin);
+	}, [editor]);
 	return null;
 };
-ReactAutoCompletePlugin.displayName = "ReactAutoCompletePlugin";
+ReactNodePlugin.displayName = "ReactNodePlugin";
 //#endregion
-//#region src/plugins/litexml/command/index.ts
+//#region src/plugins/litexml/data-source/litexml-data-source.ts
 init_debug();
-const logger$6 = createDebugLogger("plugin", "litexml");
-function toArrayXml(litexml) {
-	return Array.isArray(litexml) ? litexml : [litexml];
-}
-function tryParseChild(child, editor) {
-	try {
-		const oldNode = $getNodeByKey(child.id);
-		return {
-			newNode: $parseSerializedNodeImpl(child, editor),
-			oldNode
-		};
-	} catch (error) {
-		logger$6.error("❌ Error parsing child node:", error);
+const logger$5 = createDebugLogger("plugin", "litexml");
+var IXmlWriterContext = class {
+	createXmlNode(tagName, attributes, textContent) {
 		return {
-			newNode: null,
-			oldNode: null
+			attributes: attributes || {},
+			children: [],
+			tagName,
+			textContent
 		};
 	}
-}
-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);
-		return;
+};
+/**
+* LitexmlDataSource - Handles conversion between Lexical editor state and XML format
+* Provides read (parse XML to Lexical) and write (export Lexical to XML) capabilities
+*/
+var LitexmlDataSource = class extends DataSource {
+	constructor(dataType = "litexml", getService, service) {
+		super(dataType);
+		this.dataType = dataType;
+		this.getService = getService;
+		this.ctx = new IXmlWriterContext();
+		this.litexmlService = service || new LitexmlService();
 	}
-	if (oldNode === oldBlock) {
-		const diffNode = $createDiffNode("modify");
-		diffNode.append($cloneNode(oldBlock, editor), newNode);
-		oldNode.replace(diffNode, false);
-	} else {
-		if (!modifyBlockNodes.has(oldBlock.getKey())) {
-			modifyBlockNodes.add(oldBlock.getKey());
-			const diffNode = $createDiffNode("modify");
-			diffNode.append($cloneNode(oldBlock, editor));
-			diffNodeMap.set(oldBlock.getKey(), diffNode);
-		}
-		oldNode.replace(newNode, false);
+	readLiteXMLToInode(litexml) {
+		if (typeof litexml !== "string") throw new Error("Invalid data type. Expected string, got " + typeof litexml);
+		const xml = this.parseXMLString(litexml);
+		const inode = this.xmlToLexical(xml);
+		this.getService?.(INodeService)?.processNodeTree(inode);
+		logger$5.debug("Parsed XML to Lexical State:", inode);
+		return inode;
 	}
-}
-function finalizeModifyBlocks(modifyBlockNodes, diffNodeMap, editor) {
-	for (const blockNodeKey of modifyBlockNodes) {
-		const blockNode = $getNodeByKey(blockNodeKey);
-		const diffNode = diffNodeMap.get(blockNodeKey);
-		if (diffNode && blockNode) if (blockNode.getType() === "listitem" && $isElementNode(blockNode)) {
-			const newDiffNode = $createDiffNode("listItemModify");
-			const firstChild = diffNode.getFirstChild();
-			if (firstChild && $isElementNode(firstChild)) newDiffNode.append(firstChild);
-			const children = blockNode.getChildren();
-			const p = $createParagraphNode();
-			children.forEach((child) => {
-				child.remove();
-				p.append(child);
+	/**
+	* Parse XML string and set it to the editor
+	* @param editor - The Lexical editor instance
+	* @param data - XML string to parse
+	*/
+	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);
+				}
 			});
-			newDiffNode.append(p);
-			blockNode.append(newDiffNode);
-			continue;
-		} else {
-			diffNode.append($cloneNode(blockNode, editor));
-			blockNode.replace(diffNode, false);
+			editor.setEditorState(newState);
+		} catch (error) {
+			logger$5.error("Failed to parse XML:", error);
+			throw error;
 		}
 	}
-}
-/**
-* Wrap a block-level change with a `modify` diff: clone the old block, run the
-* provided changeFn (which should mutate nodes inside the block), then clone
-* the new block and replace it with the diff node. Useful for inline->block
-* transitions where we want to show a modify diff.
-*/
-function wrapBlockModify(oldBlock, editor, changeFn) {
-	if ($isListItemNode(oldBlock)) {
-		const diffNode = $createDiffNode("listItemModify");
-		const p = $createParagraphNode();
-		oldBlock.getChildren().forEach((child) => {
-			p.append($cloneNode(child, editor));
-		});
-		changeFn();
-		diffNode.append(p);
-		const pNew = $createParagraphNode();
-		oldBlock.getChildren().forEach((child) => {
-			pNew.append(child);
-		});
-		diffNode.append(pNew);
-		oldBlock.append(diffNode);
-		return;
-	}
-	const diffNode = $createDiffNode("modify");
-	diffNode.append($cloneNode(oldBlock, editor));
-	changeFn();
-	const newBlock = $getNodeByKey(oldBlock.getKey());
-	if (!newBlock) throw new Error("New block node not found for modify wrapper.");
-	diffNode.append($cloneNode(newBlock, editor));
-	newBlock.replace(diffNode, false);
-}
-const LITEXML_MODIFY_COMMAND = createCommand("LITEXML_MODIFY_COMMAND");
-const LITEXML_APPLY_COMMAND = createCommand("LITEXML_APPLY_COMMAND");
-const LITEXML_REMOVE_COMMAND = createCommand("LITEXML_REMOVE_COMMAND");
-const LITEXML_INSERT_COMMAND = createCommand("LITEXML_INSERT_COMMAND");
-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;
-		}, []);
+	/**
+	* Export editor content to XML format
+	* @param editor - The Lexical editor instance
+	* @param options - Write options (e.g., selection flag)
+	* @returns XML string representation of the editor content
+	*/
+	write(editor, options) {
 		try {
-			resultPayload.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$6.warn(`⚠️ Unknown action type: ${action}`);
+			if (options?.selection) return editor.getEditorState().read(() => {
+				const selection = $getSelection();
+				if (!selection) return null;
+				if ($isRangeSelection(selection)) {
+					const selectedNodes = selection.getNodes();
+					const rootNode = INodeHelper.createRootNode();
+					if (selectedNodes.some((node) => node.isInline())) {
+						const p = INodeHelper.createParagraph();
+						INodeHelper.appendChild(p, ...selectedNodes.map((node) => node.exportJSON()));
+						INodeHelper.appendChild(rootNode, p);
+					} else INodeHelper.appendChild(rootNode, ...selectedNodes.map((node) => node.exportJSON()));
+					return editor.parseEditorState({ root: rootNode }).read(() => {
+						const lexicalRootNode = $getRoot();
+						return this.lexicalToXML(lexicalRootNode);
+					});
 				}
+				return null;
+			});
+			return editor.getEditorState().read(() => {
+				const rootNode = $getRoot();
+				return this.lexicalToXML(rootNode);
 			});
-			return false;
 		} catch (error) {
-			logger$6.error("❌ Error processing LITEXML_MODIFY_COMMAND:", error);
-			return false;
+			logger$5.error("Failed to export to XML:", error);
+			throw error;
 		}
-	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_APPLY_COMMAND, (payload) => {
-		const { litexml, delay } = payload;
-		handleModify(editor, dataSource, toArrayXml(litexml), delay);
-		return false;
-	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_REMOVE_COMMAND, (payload) => {
-		const { id, delay } = payload;
-		handleRemove(editor, charToId(id), delay);
-		return false;
-	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_INSERT_COMMAND, (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$6.warn(`⚠️ Node with key ${child.id} not found for diffing.`);
-				} catch (error) {
-					logger$6.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;
+	}
+	/**
+	* Parse XML string using browser's built-in parser
+	*/
+	parseXMLString(xmlString) {
+		const doc = new DOMParser().parseFromString(xmlString, "text/xml");
+		if (doc.getElementsByTagName("parsererror").length > 0) throw new Error("Invalid XML: " + xmlString);
+		return doc;
+	}
+	/**
+	* Convert XML document to Lexical node structure
+	*/
+	xmlToLexical(xml) {
+		const rootNode = INodeHelper.createRootNode();
+		const xmlRoot = xml.documentElement;
+		if (xmlRoot) this.processXMLElement(xmlRoot, rootNode);
+		return { root: rootNode };
+	}
+	/**
+	* Recursively process XML elements and convert to Lexical nodes
+	*/
+	processXMLElement(xmlElement, parentNode) {
+		const tagName = xmlElement.tagName.toLowerCase();
+		const customReaders = this.litexmlService.getXMLReaders();
+		if (customReaders[tagName]) {
+			const readerOrReaders = customReaders[tagName];
+			const readers = Array.isArray(readerOrReaders) ? readerOrReaders : [readerOrReaders];
+			for (const reader of readers) {
+				const children = [];
+				this.processXMLChildren(xmlElement, { children });
+				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;
 						}
-					} else prevNode = prevNode.insertAfter(newNode);
-					else $insertNodes([newNode]);
-				} catch (error) {
-					logger$6.error("❌ Error replacing node:", error);
+						INodeHelper.appendChild(parentNode, ...result);
+					} else if (result) {
+						const attrId = xmlElement.getAttribute("id");
+						result.id = attrId ? charToId(attrId) : void 0;
+						INodeHelper.appendChild(parentNode, result);
+					}
+					return;
 				}
-			});
-		});
-	});
-}
-function handleRemove(editor, key, delay) {
-	editor.update(() => {
-		const node = $getNodeByKey(key);
-		if (!node) return;
-		if (!delay) {
-			node.remove();
-			return;
+			}
 		}
-		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");
-						newDiff.append(children[0]);
-						originDiffNode.replace(newDiff, false);
-						return;
-					}
-					case "listItemModify": {
-						const children = originDiffNode.getChildren();
-						originDiffNode.replace(children[0], false).selectEnd();
-						return;
-					}
-					case "remove":
-					case "unchanged": break;
-				}
-				return;
+		switch (tagName) {
+			case "p":
+			case "paragraph": {
+				const paragraph = INodeHelper.createParagraph();
+				this.processXMLChildren(xmlElement, paragraph);
+				INodeHelper.appendChild(parentNode, paragraph);
+				break;
 			}
-			if ($isListItemNode(node)) {
-				const diffNode = $createDiffNode("listItemRemove");
-				node.getChildren().forEach((child) => {
-					diffNode.append($cloneNode(child, editor));
+			case "h1":
+			case "h2":
+			case "h3":
+			case "h4":
+			case "h5":
+			case "h6": {
+				const level = parseInt(tagName.charAt(1));
+				const heading = INodeHelper.createElementNode("heading", {
+					children: [],
+					tag: `h${level}`
 				});
-				node.clear();
-				node.append(diffNode);
-			} else {
-				const diffNode = $createDiffNode("remove");
-				diffNode.append($cloneNode(node, editor));
-				node.replace(diffNode, false);
+				this.processXMLChildren(xmlElement, heading);
+				INodeHelper.appendChild(parentNode, heading);
+				break;
 			}
-		} 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;
+			case "ul":
+			case "ol":
+				xmlElement.querySelectorAll(":scope > li").forEach((li) => {
+					const listItem = INodeHelper.createElementNode("listitem", {
+						children: [],
+						value: 1
+					});
+					this.processXMLChildren(li, listItem);
+					INodeHelper.appendChild(parentNode, listItem);
+				});
+				break;
+			case "blockquote": {
+				const quote = INodeHelper.createElementNode("quote", { children: [] });
+				this.processXMLChildren(xmlElement, quote);
+				INodeHelper.appendChild(parentNode, quote);
+				break;
 			}
-			wrapBlockModify(oldBlock, editor, () => {
-				node.remove();
-			});
+			case "code": {
+				const codeNode = INodeHelper.createElementNode("codeInline", { children: [INodeHelper.createTextNode(xmlElement.textContent || "")] });
+				INodeHelper.appendChild(parentNode, codeNode);
+				break;
+			}
+			case "text": {
+				const textContent = xmlElement.textContent || "";
+				if (textContent) {
+					const textNode = INodeHelper.createTextNode(textContent);
+					INodeHelper.appendChild(parentNode, textNode);
+				}
+				break;
+			}
+			default: this.processXMLChildren(xmlElement, parentNode);
 		}
-	});
-}
-function handleInsert(editor, payload, dataSource) {
-	const { litexml, delay } = payload;
-	const isBefore = "beforeId" in payload;
-	const inode = dataSource.readLiteXMLToInode(litexml);
-	editor.update(() => {
-		try {
-			let referenceNode = null;
-			if (isBefore) if (payload.beforeId === "root") referenceNode = $getRoot().getFirstChild();
-			else referenceNode = $getNodeByKey(charToId(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));
-			if (!delay) {
-				if (isBefore) newNodes.reverse().forEach((node) => {
-					referenceNode = referenceNode.insertBefore(node);
-				});
-				else newNodes.forEach((node) => {
-					if (referenceNode) referenceNode = referenceNode.insertAfter(node);
-				});
-				return;
+	}
+	/**
+	* Process XML element's children
+	*/
+	processXMLChildren(xmlElement, parentNode) {
+		Array.from(xmlElement.childNodes).forEach((child) => {
+			if (child.nodeType === 1) this.processXMLElement(child, parentNode);
+			else if (child.nodeType === 3) {
+				const text = child.textContent || "";
+				if (text.trim()) {
+					const textNode = INodeHelper.createTextNode(text);
+					INodeHelper.appendChild(parentNode, textNode);
+				}
 			}
-			if (isBefore) if (referenceNode.isInline() === false) {
-				const originDiffNode = $closest(referenceNode, (node) => node.getType() === DiffNode.getType());
-				if (originDiffNode) referenceNode = originDiffNode;
-				newNodes.map((node) => {
-					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);
+		});
+	}
+	/**
+	* Convert Lexical node structure to XML string
+	*/
+	lexicalToXML(rootNode) {
+		const xmlLines = ["<?xml version=\"1.0\" encoding=\"UTF-8\"?>"];
+		xmlLines.push("<root>");
+		rootNode.getChildren().forEach((child) => {
+			this.nodesToXML(child, xmlLines);
+		});
+		xmlLines.push("</root>");
+		return xmlLines.join("\n");
+	}
+	/**
+	* Recursively convert Lexical nodes to XML elements
+	*/
+	nodesToXML(node, lines, indent = 1) {
+		const indentStr = " ".repeat(indent * 2);
+		const type = node.getType();
+		const customWriters = this.litexmlService.getXMLWriters();
+		const childLines = [];
+		if (customWriters[type]) {
+			const writerOrWriters = customWriters[type];
+			const writers = Array.isArray(writerOrWriters) ? writerOrWriters : [writerOrWriters];
+			for (const writer of writers) {
+				const handled = writer(node, this.ctx, indent, this.nodesToXML.bind(this));
+				if (handled) {
+					if ("lines" in handled) {
+						lines.push(...handled.lines);
+						return;
+					}
+					const attrs = this.buildXMLAttributes({
+						id: idToChar(node.getKey()),
+						...handled.attributes
 					});
-				});
-			}
-			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");
+					const openTag = `${indentStr}<${handled.tagName}${attrs}>`;
+					const closeTag = `</${handled.tagName}>`;
+					if (handled.textContent) lines.push(`${openTag}${handled.textContent}${closeTag}`);
+					else if ($isElementNode(node)) {
 						node.getChildren().forEach((child) => {
-							diffNode.append(child);
+							this.nodesToXML(child, childLines, indent + 1);
 						});
-						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);
-					});
-				});
+						lines.push(openTag, ...childLines, `${indentStr}${closeTag}`);
+					} else lines.push(openTag, `${indentStr}${closeTag}`);
+					return;
+				}
 			}
-		} catch (error) {
-			logger$6.error("❌ Error inserting node:", error);
-		}
-	});
-}
-//#endregion
-//#region src/plugins/litexml/command/diffCommand.ts
-let DiffAction = /* @__PURE__ */ function(DiffAction) {
-	DiffAction[DiffAction["Reject"] = 0] = "Reject";
-	DiffAction[DiffAction["Accept"] = 1] = "Accept";
-	return DiffAction;
-}({});
-const LITEXML_DIFFNODE_COMMAND = createCommand("LITEXML_DIFFNODE_COMMAND");
-const LITEXML_DIFFNODE_ALL_COMMAND = createCommand("LITEXML_DIFFNODE_ALL_COMMAND");
-function doAction(node, action) {
-	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();
-	}
-	if (node.diffType === "remove") {
-		if (action === 1) node.remove();
-		else if (action === 0) {
-			const children = node.getChildren();
-			node.replace(children[0], false).selectEnd();
 		}
+		if ($isElementNode(node)) node.getChildren().forEach((child) => {
+			this.nodesToXML(child, childLines, indent);
+		});
+		lines.push(...childLines);
 	}
-	if (node.diffType === "add") {
-		if (action === 1) {
-			const children = node.getChildren();
-			node.replace(children[0], false).selectEnd();
-		} else if (action === 0) node.remove();
+	/**
+	* Build XML attribute string from attributes object
+	*/
+	buildXMLAttributes(attributes) {
+		if (!attributes || typeof attributes !== "object") return "";
+		return Object.entries(attributes).filter(([, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => {
+			return ` ${key}="${this.escapeXML(String(value))}"`;
+		}).join("");
 	}
-	if (node.diffType === "listItemModify") {
-		const children = node.getChildren();
-		if (action === 1) {
-			const lastChild = children[1];
-			if (!$isElementNode(lastChild)) throw new Error("Expected element node as child of DiffNode");
-			const nodeChildrens = lastChild.getChildren();
-			for (let i = nodeChildrens.length - 1; i >= 0; i--) node.insertAfter(nodeChildrens[i]);
-			const parent = node.getParentOrThrow();
-			node.remove();
-			parent.selectEnd();
-		} else if (action === 0) {
-			const firstChild = children[0];
-			if (!$isElementNode(firstChild)) throw new Error("Expected element node as child of DiffNode");
-			const nodeChildrens = firstChild.getChildren();
-			for (let i = nodeChildrens.length - 1; i >= 0; i--) node.insertAfter(nodeChildrens[i]);
-			const parent = node.getParentOrThrow();
-			node.remove();
-			parent.selectEnd();
-		}
-	}
-	if (node.diffType === "listItemRemove") {
-		if (action === 1) node.getParentOrThrow().remove();
-		else if (action === 0) {
-			node.getChildren().forEach((child) => {
-				node.getParentOrThrow().append(child);
-			});
-			node.getParentOrThrow().selectEnd();
-			node.remove();
-		}
-	}
-	if (node.diffType === "listItemAdd") {
-		if (action === 1) {
-			node.getChildren().forEach((child) => {
-				node.getParentOrThrow().append(child);
-			});
-			node.getParentOrThrow().selectEnd();
-			node.remove();
-		} else if (action === 0) node.remove();
+	/**
+	* Escape XML special characters
+	*/
+	escapeXML(text) {
+		return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
 	}
+};
+//#endregion
+//#region src/utils/url.ts
+init_registerHotkey();
+/**
+* Shared URL validation utilities
+*/
+const URL_REGEX = /* @__PURE__ */ new RegExp(/^(?:(?:https?|ftp):\/\/)?(?:www\.)?[\dA-Za-z][\w#%+./:=?@~-]*[\w#%+/=@~-]$/);
+/**
+* Validates if a string is a valid URL
+* @param url - The URL to validate
+* @returns true if the URL is valid, false otherwise
+*/
+function isValidUrl(url) {
+	if (!url || typeof url !== "string") return false;
+	const trimmed = url.trim();
+	if (URL_REGEX.test(trimmed)) return true;
+	try {
+		const urlObj = new URL(trimmed);
+		return !!urlObj.protocol && !!urlObj.hostname;
+	} catch {}
+	if (/^[\da-z][\w#%+./:=?@~-]*\.[\w#%+/:=?@~-]+$/i.test(trimmed)) return true;
+	return false;
 }
-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);
-		});
-		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());
-		});
-		if (!nodes.length) return false;
-		editor.update(() => {
-			nodes.forEach((node) => {
-				doAction(node, action);
-			});
-		});
-		return false;
-	}, COMMAND_PRIORITY_EDITOR));
+/**
+* Checks if text is a pure URL (single URL without other text)
+* @param text - The text to check
+* @returns true if text is a pure URL, false otherwise
+*/
+function isPureUrl(text) {
+	if (!text || typeof text !== "string") return false;
+	const trimmed = text.trim();
+	if (trimmed.includes("\n")) return false;
+	return isValidUrl(trimmed);
 }
 //#endregion
-//#region src/plugins/litexml/data-source/litexml-data-source.ts
-init_helper();
-init_debug();
-const logger$5 = createDebugLogger("plugin", "litexml");
-var IXmlWriterContext = class {
-	createXmlNode(tagName, attributes, textContent) {
-		return {
-			attributes: attributes || {},
-			children: [],
-			tagName,
-			textContent
-		};
-	}
-};
+//#region src/plugins/litexml/plugin/index.ts
 /**
-* LitexmlDataSource - Handles conversion between Lexical editor state and XML format
-* Provides read (parse XML to Lexical) and write (export Lexical to XML) capabilities
+* LitexmlPlugin - A plugin that provides XML-based data source support
+* Allows converting between Lexical editor state and XML format
 */
-var LitexmlDataSource = class extends DataSource {
-	constructor(dataType = "litexml", getService, service) {
-		super(dataType);
-		this.dataType = dataType;
-		this.getService = getService;
-		this.ctx = new IXmlWriterContext();
-		this.litexmlService = service || new LitexmlService();
+const LitexmlPlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "LitexmlPlugin";
 	}
-	readLiteXMLToInode(litexml) {
-		if (typeof litexml !== "string") throw new Error("Invalid data type. Expected string, got " + typeof litexml);
-		const xml = this.parseXMLString(litexml);
-		const inode = this.xmlToLexical(xml);
-		this.getService?.(INodeService)?.processNodeTree(inode);
-		logger$5.debug("Parsed XML to Lexical State:", inode);
-		return inode;
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		this.config = config;
+		kernel.registerThemes({ diffNode: config?.theme || "editor_diffNode" });
+		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.registerDecorator(DiffNode.getType(), {
+			queryDOM: (el) => el.querySelector(".toolbar"),
+			render: (node, editor) => {
+				return config?.decorator ? config.decorator(node, editor) : null;
+			}
+		});
+		if (config?.enabled !== false) kernel.registerDataSource(this.datasource);
 	}
-	/**
-	* Parse XML string and set it to the editor
-	* @param editor - The Lexical editor instance
-	* @param data - XML string to parse
-	*/
-	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);
-				}
+	onInit(editor) {
+		this.register(registerLiteXMLCommand(editor, this.datasource));
+		this.register(registerLiteXMLDiffCommand(editor));
+		this.register(editor.registerNodeTransform(DiffNode, (node) => {
+			if (node.diffType === "modify" && node.getChildrenSize() === 1) node.setDiffType("remove");
+		}));
+		this.register(editor.registerUpdateListener(({ editorState, prevEditorState }) => {
+			if (editorState === prevEditorState) return;
+			editor.update(() => {
+				const diffNodes = $nodesOfType(DiffNode);
+				for (const node of diffNodes) if (node.diffType === "modify" && node.getChildrenSize() === 1) node.setDiffType("remove");
 			});
-			editor.setEditorState(newState);
-		} catch (error) {
-			logger$5.error("Failed to parse XML:", error);
-			throw error;
-		}
+		}));
+		this.registerLiteXml();
+		this.registerMarkdown();
 	}
-	/**
-	* Export editor content to XML format
-	* @param editor - The Lexical editor instance
-	* @param options - Write options (e.g., selection flag)
-	* @returns XML string representation of the editor content
-	*/
-	write(editor, options) {
-		try {
-			if (options?.selection) return editor.getEditorState().read(() => {
-				const selection = $getSelection();
-				if (!selection) return null;
-				if ($isRangeSelection(selection)) {
-					const selectedNodes = selection.getNodes();
-					const rootNode = INodeHelper.createRootNode();
-					if (selectedNodes.some((node) => node.isInline())) {
-						const p = INodeHelper.createParagraph();
-						INodeHelper.appendChild(p, ...selectedNodes.map((node) => node.exportJSON()));
-						INodeHelper.appendChild(rootNode, p);
-					} else INodeHelper.appendChild(rootNode, ...selectedNodes.map((node) => node.exportJSON()));
-					return editor.parseEditorState({ root: rootNode }).read(() => {
-						const lexicalRootNode = $getRoot();
-						return this.lexicalToXML(lexicalRootNode);
+	registerLiteXml() {
+		this.service.registerXMLWriter(DiffNode.getType(), (node, ctx, indent, nodeToXML) => {
+			const diffNode = node;
+			const lines = [];
+			switch (diffNode.diffType) {
+				case "modify":
+					nodeToXML(diffNode.getChildAtIndex(1), lines, indent);
+					break;
+				case "add":
+					nodeToXML(diffNode.getChildAtIndex(0), lines, indent);
+					break;
+				case "remove": break;
+				case "listItemModify":
+					diffNode.getChildAtIndex(1).getChildren().forEach((child) => {
+						nodeToXML(child, lines, indent);
 					});
-				}
-				return null;
-			});
-			return editor.getEditorState().read(() => {
-				const rootNode = $getRoot();
-				return this.lexicalToXML(rootNode);
-			});
-		} catch (error) {
-			logger$5.error("Failed to export to XML:", error);
-			throw error;
-		}
-	}
-	/**
-	* Parse XML string using browser's built-in parser
-	*/
-	parseXMLString(xmlString) {
-		const doc = new DOMParser().parseFromString(xmlString, "text/xml");
-		if (doc.getElementsByTagName("parsererror").length > 0) throw new Error("Invalid XML: " + xmlString);
-		return doc;
-	}
-	/**
-	* Convert XML document to Lexical node structure
-	*/
-	xmlToLexical(xml) {
-		const rootNode = INodeHelper.createRootNode();
-		const xmlRoot = xml.documentElement;
-		if (xmlRoot) this.processXMLElement(xmlRoot, rootNode);
-		return { root: rootNode };
-	}
-	/**
-	* Recursively process XML elements and convert to Lexical nodes
-	*/
-	processXMLElement(xmlElement, parentNode) {
-		const tagName = xmlElement.tagName.toLowerCase();
-		const customReaders = this.litexmlService.getXMLReaders();
-		if (customReaders[tagName]) {
-			const readerOrReaders = customReaders[tagName];
-			const readers = Array.isArray(readerOrReaders) ? readerOrReaders : [readerOrReaders];
-			for (const reader of readers) {
-				const children = [];
-				this.processXMLChildren(xmlElement, { children });
-				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;
-						}
-						INodeHelper.appendChild(parentNode, ...result);
-					} else if (result) {
-						const attrId = xmlElement.getAttribute("id");
-						result.id = attrId ? charToId(attrId) : void 0;
-						INodeHelper.appendChild(parentNode, result);
-					}
-					return;
-				}
-			}
-		}
-		switch (tagName) {
-			case "p":
-			case "paragraph": {
-				const paragraph = INodeHelper.createParagraph();
-				this.processXMLChildren(xmlElement, paragraph);
-				INodeHelper.appendChild(parentNode, paragraph);
-				break;
-			}
-			case "h1":
-			case "h2":
-			case "h3":
-			case "h4":
-			case "h5":
-			case "h6": {
-				const level = parseInt(tagName.charAt(1));
-				const heading = INodeHelper.createElementNode("heading", {
-					children: [],
-					tag: `h${level}`
-				});
-				this.processXMLChildren(xmlElement, heading);
-				INodeHelper.appendChild(parentNode, heading);
-				break;
-			}
-			case "ul":
-			case "ol":
-				xmlElement.querySelectorAll(":scope > li").forEach((li) => {
-					const listItem = INodeHelper.createElementNode("listitem", {
-						children: [],
-						value: 1
-					});
-					this.processXMLChildren(li, listItem);
-					INodeHelper.appendChild(parentNode, listItem);
-				});
-				break;
-			case "blockquote": {
-				const quote = INodeHelper.createElementNode("quote", { children: [] });
-				this.processXMLChildren(xmlElement, quote);
-				INodeHelper.appendChild(parentNode, quote);
-				break;
-			}
-			case "code": {
-				const codeNode = INodeHelper.createElementNode("codeInline", { children: [INodeHelper.createTextNode(xmlElement.textContent || "")] });
-				INodeHelper.appendChild(parentNode, codeNode);
-				break;
-			}
-			case "text": {
-				const textContent = xmlElement.textContent || "";
-				if (textContent) {
-					const textNode = INodeHelper.createTextNode(textContent);
-					INodeHelper.appendChild(parentNode, textNode);
-				}
-				break;
-			}
-			default: this.processXMLChildren(xmlElement, parentNode);
-		}
-	}
-	/**
-	* Process XML element's children
-	*/
-	processXMLChildren(xmlElement, parentNode) {
-		Array.from(xmlElement.childNodes).forEach((child) => {
-			if (child.nodeType === 1) this.processXMLElement(child, parentNode);
-			else if (child.nodeType === 3) {
-				const text = child.textContent || "";
-				if (text.trim()) {
-					const textNode = INodeHelper.createTextNode(text);
-					INodeHelper.appendChild(parentNode, textNode);
-				}
-			}
-		});
-	}
-	/**
-	* Convert Lexical node structure to XML string
-	*/
-	lexicalToXML(rootNode) {
-		const xmlLines = ["<?xml version=\"1.0\" encoding=\"UTF-8\"?>"];
-		xmlLines.push("<root>");
-		rootNode.getChildren().forEach((child) => {
-			this.nodesToXML(child, xmlLines);
-		});
-		xmlLines.push("</root>");
-		return xmlLines.join("\n");
-	}
-	/**
-	* Recursively convert Lexical nodes to XML elements
-	*/
-	nodesToXML(node, lines, indent = 1) {
-		const indentStr = " ".repeat(indent * 2);
-		const type = node.getType();
-		const customWriters = this.litexmlService.getXMLWriters();
-		const childLines = [];
-		if (customWriters[type]) {
-			const writerOrWriters = customWriters[type];
-			const writers = Array.isArray(writerOrWriters) ? writerOrWriters : [writerOrWriters];
-			for (const writer of writers) {
-				const handled = writer(node, this.ctx, indent, this.nodesToXML.bind(this));
-				if (handled) {
-					if ("lines" in handled) {
-						lines.push(...handled.lines);
-						return;
-					}
-					const attrs = this.buildXMLAttributes({
-						id: idToChar(node.getKey()),
-						...handled.attributes
-					});
-					const openTag = `${indentStr}<${handled.tagName}${attrs}>`;
-					const closeTag = `</${handled.tagName}>`;
-					if (handled.textContent) lines.push(`${openTag}${handled.textContent}${closeTag}`);
-					else if ($isElementNode(node)) {
-						node.getChildren().forEach((child) => {
-							this.nodesToXML(child, childLines, indent + 1);
-						});
-						lines.push(openTag, ...childLines, `${indentStr}${closeTag}`);
-					} else lines.push(openTag, `${indentStr}${closeTag}`);
-					return;
-				}
-			}
-		}
-		if ($isElementNode(node)) node.getChildren().forEach((child) => {
-			this.nodesToXML(child, childLines, indent);
-		});
-		lines.push(...childLines);
-	}
-	/**
-	* Build XML attribute string from attributes object
-	*/
-	buildXMLAttributes(attributes) {
-		if (!attributes || typeof attributes !== "object") return "";
-		return Object.entries(attributes).filter(([, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => {
-			return ` ${key}="${this.escapeXML(String(value))}"`;
-		}).join("");
-	}
-	/**
-	* Escape XML special characters
-	*/
-	escapeXML(text) {
-		return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
-	}
-};
-//#endregion
-//#region src/plugins/litexml/plugin/index.ts
-init_plugin();
-/**
-* LitexmlPlugin - A plugin that provides XML-based data source support
-* Allows converting between Lexical editor state and XML format
-*/
-const LitexmlPlugin = class extends KernelPlugin {
-	static {
-		this.pluginName = "LitexmlPlugin";
-	}
-	constructor(kernel, config) {
-		super();
-		this.kernel = kernel;
-		this.config = config;
-		kernel.registerThemes({ diffNode: config?.theme || "editor_diffNode" });
-		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.registerDecorator(DiffNode.getType(), {
-			queryDOM: (el) => el.querySelector(".toolbar"),
-			render: (node, editor) => {
-				return config?.decorator ? config.decorator(node, editor) : null;
-			}
-		});
-		if (config?.enabled !== false) kernel.registerDataSource(this.datasource);
-	}
-	onInit(editor) {
-		this.register(registerLiteXMLCommand(editor, this.datasource));
-		this.register(registerLiteXMLDiffCommand(editor));
-		this.register(editor.registerNodeTransform(DiffNode, (node) => {
-			if (node.diffType === "modify" && node.getChildrenSize() === 1) node.setDiffType("remove");
-		}));
-		this.register(editor.registerUpdateListener(({ editorState, prevEditorState }) => {
-			if (editorState === prevEditorState) return;
-			editor.update(() => {
-				const diffNodes = $nodesOfType(DiffNode);
-				for (const node of diffNodes) if (node.diffType === "modify" && node.getChildrenSize() === 1) node.setDiffType("remove");
-			});
-		}));
-		this.registerLiteXml();
-		this.registerMarkdown();
-	}
-	registerLiteXml() {
-		this.service.registerXMLWriter(DiffNode.getType(), (node, ctx, indent, nodeToXML) => {
-			const diffNode = node;
-			const lines = [];
-			switch (diffNode.diffType) {
-				case "modify":
-					nodeToXML(diffNode.getChildAtIndex(1), lines, indent);
-					break;
-				case "add":
-					nodeToXML(diffNode.getChildAtIndex(0), lines, indent);
-					break;
-				case "remove": break;
-				case "listItemModify":
-					diffNode.getChildAtIndex(1).getChildren().forEach((child) => {
-						nodeToXML(child, lines, indent);
-					});
-					break;
-				default: break;
-			}
-			return { lines };
-		});
+					break;
+				default: break;
+			}
+			return { lines };
+		});
 	}
 	registerMarkdown() {
 		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(DiffNode.getType(), (ctx, node) => {
@@ -1181,7 +873,7 @@ const LitexmlPlugin = class extends KernelPlugin {
 };
 //#endregion
 //#region src/plugins/litexml/react/DiffNodeToolbar/style.ts
-const styles$13 = createStaticStyles(({ css, cssVar }) => ({
+const styles$14 = createStaticStyles(({ css, cssVar }) => ({
 	accept: css`
     color: ${cssVar.colorSuccess};
   `,
@@ -1210,7 +902,7 @@ const ReactDiffNodeToolbar = ({ editor, node }) => {
 		editor,
 		node,
 		children: /* @__PURE__ */ jsxs(Block, {
-			className: isDarkMode ? styles$13.toolbarDark : styles$13.toolbarLight,
+			className: isDarkMode ? styles$14.toolbarDark : styles$14.toolbarLight,
 			gap: 2,
 			horizontal: true,
 			padding: 2,
@@ -1218,7 +910,7 @@ const ReactDiffNodeToolbar = ({ editor, node }) => {
 			variant: "outlined",
 			children: [/* @__PURE__ */ jsx(ActionIcon, {
 				"aria-label": "Reject change",
-				className: styles$13.reject,
+				className: styles$14.reject,
 				danger: true,
 				icon: X,
 				onClick: () => {
@@ -1234,7 +926,7 @@ const ReactDiffNodeToolbar = ({ editor, node }) => {
 				title: t("modifier.reject")
 			}), /* @__PURE__ */ jsx(ActionIcon, {
 				"aria-label": "Accept change",
-				className: styles$13.accept,
+				className: styles$14.accept,
 				icon: Check,
 				onClick: () => {
 					editor.dispatchCommand(LITEXML_DIFFNODE_COMMAND, {
@@ -1254,7 +946,7 @@ const ReactDiffNodeToolbar = ({ editor, node }) => {
 ReactDiffNodeToolbar.displayName = "ReactDiffNodeToolbar";
 //#endregion
 //#region src/plugins/litexml/react/style.ts
-const styles$12 = createStaticStyles(({ css, cssVar }) => css`
+const styles$13 = createStaticStyles(({ css, cssVar }) => css`
     position: relative;
 
     .toolbar {
@@ -1385,7 +1077,7 @@ const ReactLiteXmlPlugin = () => {
 				editor,
 				node
 			}),
-			theme: styles$12
+			theme: styles$13
 		});
 	}, [editor]);
 	return null;
@@ -1514,6 +1206,1132 @@ const CodePlugin = class extends KernelPlugin {
 	}
 };
 //#endregion
+//#region src/plugins/hr/command/index.ts
+const INSERT_HORIZONTAL_RULE_COMMAND = createCommand("INSERT_HORIZONTAL_RULE_COMMAND");
+function registerHorizontalRuleCommand(editor) {
+	return editor.registerCommand(INSERT_HORIZONTAL_RULE_COMMAND, () => {
+		editor.update(() => {
+			$insertNodes([$createHorizontalRuleNode()]);
+		});
+		return true;
+	}, COMMAND_PRIORITY_EDITOR);
+}
+//#endregion
+//#region src/plugins/hr/plugin/index.ts
+init_helper();
+init_plugin();
+const HRPlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "HRPlugin";
+	}
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		kernel.registerNodes([HorizontalRuleNode]);
+		kernel.registerThemes({ hr: config?.theme || "" });
+		this.registerDecorator(kernel, "horizontalrule", (node, editor) => {
+			return config?.decorator ? config.decorator(node, editor) : null;
+		});
+	}
+	onInit(editor) {
+		this.register(registerHorizontalRuleCommand(editor));
+		this.registerMarkdown();
+		this.registerLiteXml();
+	}
+	registerLiteXml() {
+		const litexmlService = this.kernel.requireService(ILitexmlService);
+		if (!litexmlService) return;
+		litexmlService.registerXMLWriter(HorizontalRuleNode.getType(), (node, ctx) => {
+			if ($isHorizontalRuleNode(node)) return ctx.createXmlNode("hr", {});
+			return false;
+		});
+		litexmlService.registerXMLReader("hr", () => {
+			return INodeHelper.createElementNode(HorizontalRuleNode.getType(), {});
+		});
+	}
+	registerMarkdown() {
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownShortCut({
+			regExp: /^(---|\*\*\*|___)$/,
+			replace: (parentNode, _1, _2, isImport) => {
+				const line = $createHorizontalRuleNode();
+				if (isImport || parentNode.getNextSibling()) parentNode.replace(line);
+				else parentNode.insertBefore(line);
+				line.selectNext();
+			},
+			trigger: "enter",
+			type: "element"
+		});
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(HorizontalRuleNode.getType(), (ctx, node) => {
+			if ($isHorizontalRuleNode(node)) ctx.appendLine("---\n\n");
+		});
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownReader("thematicBreak", () => {
+			return INodeHelper.createElementNode("horizontalrule", {});
+		});
+	}
+};
+//#endregion
+//#region src/utils/cx.ts
+const cx$1 = (...classNames) => classNames.filter(Boolean).join(" ");
+//#endregion
+//#region src/plugins/list/utils/index.ts
+const LIST_INDENT_SIZE = 4;
+function getIndent(whitespaces) {
+	const tabs = whitespaces.match(/\t/g);
+	const spaces = whitespaces.match(/ /g);
+	let indent = 0;
+	if (tabs) indent += tabs.length;
+	if (spaces) indent += Math.floor(spaces.length / LIST_INDENT_SIZE);
+	return indent;
+}
+const listReplace = (listType) => {
+	return (parentNode, children, match, isImport) => {
+		const previousNode = parentNode.getPreviousSibling();
+		const nextNode = parentNode.getNextSibling();
+		const listItem = $createListItemNode(listType === "check" ? match[3] === "x" : void 0);
+		if ($isListNode(nextNode) && nextNode.getListType() === listType) {
+			const firstChild = nextNode.getFirstChild();
+			if (firstChild !== null) firstChild.insertBefore(listItem);
+			else nextNode.append(listItem);
+			parentNode.remove();
+		} else if ($isListNode(previousNode) && previousNode.getListType() === listType) {
+			previousNode.append(listItem);
+			parentNode.remove();
+		} else {
+			const list = $createListNode(listType, listType === "number" ? Number(match[2]) : void 0);
+			list.append(listItem);
+			parentNode.replace(list);
+		}
+		listItem.append(...children);
+		if (!isImport) listItem.select(0, 0);
+		const indent = getIndent(match[1]);
+		if (indent) listItem.setIndent(indent);
+	};
+};
+function $indentOverTab(selection) {
+	if ($filter(selection.getNodes(), (node) => {
+		if ($isBlockElementNode(node) && node.canIndent()) return node;
+		return null;
+	}).length > 0) return true;
+	const anchor = selection.anchor;
+	const focus = selection.focus;
+	const first = focus.isBefore(anchor) ? focus : anchor;
+	const firstBlock = $getNearestBlockElementAncestorOrThrow(first.getNode());
+	if (firstBlock.canIndent()) {
+		const firstBlockKey = firstBlock.getKey();
+		let selectionAtStart = $createRangeSelection();
+		selectionAtStart.anchor.set(firstBlockKey, 0, "element");
+		selectionAtStart.focus.set(firstBlockKey, 0, "element");
+		selectionAtStart = $normalizeSelection__EXPERIMENTAL(selectionAtStart);
+		if (selectionAtStart.anchor.is(first)) return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/plugins/list/plugin/registry.ts
+init_hotkey();
+function registerListCommands(editor, kernel, options) {
+	const { enableHotkey = true } = options || {};
+	return mergeRegister(kernel.registerHotkey(HotkeyEnum.BulletList, () => editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND$1, void 0), {
+		enabled: enableHotkey,
+		preventDefault: true,
+		stopImmediatePropagation: true
+	}), kernel.registerHotkey(HotkeyEnum.NumberList, () => editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND$1, void 0), {
+		enabled: enableHotkey,
+		preventDefault: true,
+		stopImmediatePropagation: true
+	}), editor.registerCommand(KEY_TAB_COMMAND, (event) => {
+		const selection = $getSelection();
+		if (!$isRangeSelection(selection)) return false;
+		event.preventDefault();
+		const command = $indentOverTab(selection) ? event.shiftKey ? OUTDENT_CONTENT_COMMAND : INDENT_CONTENT_COMMAND : INSERT_TAB_COMMAND;
+		return editor.dispatchCommand(command, void 0);
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(KEY_BACKSPACE_COMMAND, (event) => {
+		const selection = $getSelection();
+		if (!$isRangeSelection(selection) || !selection.isCollapsed()) return false;
+		const anchor = selection.anchor;
+		if (anchor.offset !== 0) return false;
+		const anchorNode = anchor.getNode();
+		let listItemNode;
+		if ($isListItemNode(anchorNode)) listItemNode = anchorNode;
+		else if ($isTextNode(anchorNode)) {
+			if (anchorNode.getPreviousSibling()) return false;
+			const parent = anchorNode.getParentOrThrow();
+			if (!$isListItemNode(parent)) return false;
+			listItemNode = parent;
+		}
+		if (!listItemNode || !$isRootNode(listItemNode.getParent()?.getParent())) return false;
+		const listNode = listItemNode.getParentOrThrow();
+		queueMicrotask(() => {
+			editor.update(() => {
+				if (!listItemNode) return;
+				let newlistNode;
+				if (listItemNode.getPreviousSibling() === null) {
+					listItemNode.replace($createParagraphNode(), true).select(0, 0);
+					return;
+				}
+				let next = listItemNode.getNextSibling();
+				if (next) newlistNode = $createListNode(listNode.getListType(), listItemNode.getValue());
+				while (next && newlistNode) {
+					next.remove();
+					newlistNode.append(next);
+					next = next.getNextSibling();
+				}
+				const p = listItemNode.replace($createParagraphNode(), true);
+				p.remove();
+				listNode.insertAfter(p);
+				if (newlistNode) p.insertAfter(newlistNode);
+				p.select(0, 0);
+			});
+		});
+		event.stopImmediatePropagation();
+		event.preventDefault();
+		return true;
+	}, COMMAND_PRIORITY_LOW));
+}
+//#endregion
+//#region src/plugins/list/plugin/index.ts
+init_helper();
+init_plugin();
+const ORDERED_LIST_REGEX = /^(\s*)(\d+)\.\s/;
+const UNORDERED_LIST_REGEX = /^(\s*)[*+-]\s/;
+const CHECK_LIST_REGEX = /^(\s*)(?:-\s)?\s?(\[(\s|x)?])\s/i;
+const ListPlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "ListPlugin";
+	}
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		this.config = config;
+		kernel.registerNodes([ListNode, ListItemNode]);
+		kernel.registerThemes({ list: {
+			checklist: "editor_listItemCheck",
+			listitem: "editor_listItem",
+			listitemChecked: "editor_listItemChecked",
+			listitemUnchecked: "editor_listItemUnchecked",
+			nested: { listitem: "editor_listItemNested" },
+			ol: cx$1("editor_listOrdered", config?.theme),
+			olDepth: [
+				"editor_listOrdered dp1",
+				"editor_listOrdered dp2",
+				"editor_listOrdered dp3",
+				"editor_listOrdered dp4",
+				"editor_listOrdered dp5"
+			],
+			ul: cx$1("editor_listUnordered", config?.theme)
+		} });
+	}
+	onInit(editor) {
+		this.register(registerList(editor));
+		this.register(registerCheckList(editor));
+		this.register(registerListStrictIndentTransform(editor));
+		this.register(registerListCommands(editor, this.kernel, { enableHotkey: this.config?.enableHotkey }));
+		this.registerMarkdown();
+		this.registerLiteXml();
+	}
+	registerLiteXml() {
+		const litexmlService = this.kernel.requireService(ILitexmlService);
+		if (!litexmlService) return;
+		litexmlService.registerXMLWriter(ListNode.getType(), (node, ctx) => {
+			if ($isListNode(node)) {
+				const tagName = node.getListType() === "number" ? "ol" : "ul";
+				const attributes = {};
+				if (node.getListType() === "number" && node.getStart() !== 1) attributes.start = node.getStart().toString();
+				return ctx.createXmlNode(tagName, attributes);
+			}
+			return false;
+		});
+		litexmlService.registerXMLWriter(ListItemNode.getType(), (node, ctx) => {
+			if ($isListItemNode(node)) return ctx.createXmlNode("li");
+			return false;
+		});
+		litexmlService.registerXMLReader("ol", (xmlNode, children) => {
+			return INodeHelper.createElementNode("list", {
+				children,
+				direction: "ltr",
+				format: "",
+				indent: 0,
+				listType: "number",
+				start: xmlNode.getAttribute("start") ? parseInt(xmlNode.getAttribute("start"), 10) : 1,
+				tag: "ol",
+				version: 1
+			});
+		});
+		litexmlService.registerXMLReader("ul", (xmlNode, children) => {
+			return INodeHelper.createElementNode("list", {
+				children,
+				direction: "ltr",
+				format: "",
+				indent: 0,
+				listType: "bullet",
+				start: 1,
+				tag: "ul",
+				version: 1
+			});
+		});
+		litexmlService.registerXMLReader("li", (xmlNode, children) => {
+			return INodeHelper.createElementNode("listitem", {
+				children,
+				direction: "ltr",
+				format: "",
+				indent: 0,
+				type: "listitem",
+				version: 1
+			});
+		});
+	}
+	registerMarkdown() {
+		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
+		if (!markdownService) return;
+		markdownService.registerMarkdownShortCut({
+			regExp: UNORDERED_LIST_REGEX,
+			replace: listReplace("bullet"),
+			type: "element"
+		});
+		markdownService.registerMarkdownShortCut({
+			regExp: ORDERED_LIST_REGEX,
+			replace: listReplace("number"),
+			type: "element"
+		});
+		markdownService.registerMarkdownShortCut({
+			regExp: CHECK_LIST_REGEX,
+			replace: listReplace("check"),
+			type: "element"
+		});
+		markdownService.registerMarkdownWriter(ListNode.getType(), (ctx, node) => {
+			if ($isListNode(node)) ctx.wrap("", "\n");
+		});
+		const getLevel = (node) => {
+			if (!node) return 0;
+			if ($isRootNode(node.getParent())) return 0;
+			const parent = node.getParent();
+			if (!parent) return 0;
+			return getLevel($getNearestNodeOfType(parent, ListNode)) + 1;
+		};
+		markdownService.registerMarkdownWriter(ListItemNode.getType(), (ctx, node) => {
+			const parent = node.getParent();
+			if ($isListItemNode(node) && $isListNode(parent)) {
+				if ($isListNode(node.getFirstChild())) return;
+				const level = getLevel(parent);
+				const prefix = "    ".repeat(level);
+				switch (parent.getListType()) {
+					case "bullet":
+						ctx.wrap(prefix + "- ", "\n");
+						break;
+					case "number":
+						ctx.wrap(`${prefix}${node.getValue()}. `, "\n");
+						break;
+					case "check":
+						ctx.wrap(`${prefix}- [${node.getChecked() ? "x" : " "}] `, "\n");
+						break;
+					default: break;
+				}
+			}
+		});
+		markdownService.registerMarkdownReader("list", (node, children) => {
+			const isCheck = node.children?.[0]?.type === "listItem" && typeof node.children?.[0]?.checked === "boolean";
+			let start = node.start || 1;
+			return INodeHelper.createElementNode("list", {
+				children: children.map((v) => {
+					if (v.type === "listitem") v.value = start++;
+					return v;
+				}),
+				direction: "ltr",
+				format: "",
+				indent: 0,
+				listType: isCheck ? "check" : node.ordered ? "number" : "bullet",
+				start: node.start || 1,
+				tag: node.ordered ? "ol" : "ul",
+				version: 1
+			});
+		});
+		markdownService.registerMarkdownReader("listItem", (node, children, index) => {
+			return children.map((v) => {
+				if (v.type === "paragraph") return INodeHelper.createElementNode("listitem", {
+					checked: typeof node.checked === "boolean" ? node.checked : void 0,
+					children: v.children,
+					direction: "ltr",
+					format: "",
+					indent: 0,
+					type: "listitem",
+					value: index + 1,
+					version: 1
+				});
+				else if (v.type === "list") return INodeHelper.createElementNode("listitem", {
+					children: [v],
+					direction: "ltr",
+					format: "",
+					indent: 0,
+					type: "listitem",
+					value: index + 1,
+					version: 1
+				});
+				return v;
+			});
+		});
+	}
+};
+//#endregion
+//#region src/plugins/table/command/index.ts
+const INSERT_TABLE_COMMAND = createCommand();
+const SELECT_TABLE_COMMAND = createCommand();
+function registerTableCommand(editor) {
+	return mergeRegister(editor.registerCommand(INSERT_TABLE_COMMAND, ({ rows, columns, includeHeaders }) => {
+		const selection = $getSelection() || $getPreviousSelection();
+		if (!selection || !$isRangeSelection(selection)) return false;
+		if ($findTableNode(selection.anchor.getNode())) return false;
+		const anchorNode = selection.anchor.getNode();
+		const tableNode = $createTableNodeWithDimensions(Number(rows), Number(columns), includeHeaders);
+		if ($isElementNode(anchorNode) && anchorNode.isEmpty()) anchorNode.replace(tableNode);
+		else $insertNodeToNearestRoot(tableNode);
+		const firstDescendant = tableNode.getFirstDescendant();
+		if ($isTextNode(firstDescendant)) firstDescendant.select();
+		return true;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(SELECT_TABLE_COMMAND, ({ table, columnIndex, rowIndex }) => {
+		editor.update(() => {
+			const prevSelection = $getSelection();
+			const tableNode = $getNodeByKey(table);
+			if (!tableNode || !$isTableNode(tableNode)) return;
+			const tableSelection = $isTableSelection(prevSelection) ? prevSelection : $createTableSelection();
+			if (rowIndex !== void 0) {
+				const firstRow = tableNode.getChildren()[rowIndex];
+				if (!firstRow) return;
+				const firstCell = firstRow.getFirstChild();
+				const lastCell = firstRow.getLastChild();
+				if (!firstCell || !lastCell) return;
+				tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
+				$setSelection(tableSelection);
+			} else if (columnIndex !== void 0) {
+				const firstRow = tableNode.getFirstChild();
+				const lastRow = tableNode.getLastChild();
+				if (!firstRow || !lastRow) return;
+				const firstCell = firstRow.getChildren()[columnIndex];
+				const lastCell = lastRow.getChildren()[columnIndex];
+				if (!firstCell || !lastCell) return;
+				tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
+				$setSelection(tableSelection);
+			} else {
+				const firstRow = tableNode.getFirstChild();
+				const lastRow = tableNode.getLastChild();
+				if (!firstRow || !lastRow) return;
+				const firstCell = firstRow.getFirstChild();
+				const lastCell = lastRow.getLastChild();
+				if (!firstCell || !lastCell) return;
+				tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
+				$setSelection(tableSelection);
+			}
+		});
+		return false;
+	}, COMMAND_PRIORITY_EDITOR));
+}
+//#endregion
+//#region src/plugins/table/node/index.ts
+const OriginalCreateDOM = TableNode.prototype.createDOM;
+function patchTableNode() {
+	Object.defineProperty(TableNode.prototype, "createDOM", {
+		configurable: true,
+		enumerable: false,
+		value: function(config, editor) {
+			const table = OriginalCreateDOM.call(this, config, editor);
+			const controller = document.createElement("div");
+			table.append(controller);
+			return table;
+		},
+		writable: true
+	});
+}
+//#endregion
+//#region src/plugins/table/plugin/index.ts
+init_helper();
+init_plugin();
+const tableCellProcessor = (before, content, after) => {
+	return before + content.replace(/\n+$/, "").replaceAll(/\n+/g, "<br />") + after;
+};
+function isHeadlessEditor(editor) {
+	return editor._headless === true;
+}
+const TablePlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "TablePlugin";
+	}
+	constructor(kernel, options) {
+		super();
+		this.kernel = kernel;
+		patchTableNode();
+		kernel.registerNodes([
+			TableNode$1,
+			TableRowNode,
+			TableCellNode
+		]);
+		kernel.registerThemes({
+			table: "editor_table",
+			tableCell: "editor_table_cell",
+			tableCellHeader: "editor_table_cell_header",
+			tableCellSelected: "editor_table_cell_selected",
+			tableScrollableWrapper: cx$1("editor_table_scrollable_wrapper", options?.theme)
+		});
+	}
+	onInit(editor) {
+		this.register(registerTableCellUnmergeTransform(editor));
+		if (!isHeadlessEditor(editor)) {
+			setScrollableTablesActive(editor, true);
+			this.register(registerTablePlugin(editor));
+			this.register(registerTableSelectionObserver(editor));
+			this.register(registerTableCommand(editor));
+		}
+		this.registerMarkdown();
+		this.registerLiteXml();
+	}
+	registerLiteXml() {
+		const litexmlService = this.kernel.requireService(ILitexmlService);
+		if (!litexmlService) return;
+		litexmlService.registerXMLWriter(TableNode$1.getType(), (node, ctx) => {
+			if ($isTableNode(node)) {
+				const attributes = {};
+				const colWidths = node.getColWidths();
+				if (colWidths && colWidths.length > 0) attributes.colWidths = colWidths.join(",");
+				return ctx.createXmlNode("table", attributes);
+			}
+			return false;
+		});
+		litexmlService.registerXMLWriter(TableRowNode.getType(), (node, ctx) => {
+			if (node instanceof TableRowNode) return ctx.createXmlNode("tr", {});
+			return false;
+		});
+		litexmlService.registerXMLWriter(TableCellNode.getType(), (node, ctx) => {
+			if (node instanceof TableCellNode) {
+				const attributes = {};
+				if (node.getColSpan() > 1) attributes.colSpan = node.getColSpan().toString();
+				if (node.getRowSpan() > 1) attributes.rowSpan = node.getRowSpan().toString();
+				if (node.getBackgroundColor()) attributes.backgroundColor = node.getBackgroundColor();
+				return ctx.createXmlNode("td", attributes);
+			}
+			return false;
+		});
+		litexmlService.registerXMLReader("table", (xmlNode, children) => {
+			const colWidthsAttr = xmlNode.getAttribute("colWidths");
+			const colWidths = colWidthsAttr ? colWidthsAttr.split(",").map((width) => parseInt(width, 10)) : [];
+			let maxTdlen = 1;
+			for (const child of children) if ((child.children?.length || -1) > maxTdlen) maxTdlen = child.children.length;
+			return INodeHelper.createElementNode(TableNode$1.getType(), {
+				children,
+				colWidths: colWidths.length > 0 ? colWidths : new Array(maxTdlen).fill(750 / maxTdlen),
+				direction: null,
+				format: "",
+				indent: 0,
+				version: 1
+			});
+		});
+		litexmlService.registerXMLReader("tr", (_xmlNode, children) => {
+			return INodeHelper.createElementNode(TableRowNode.getType(), {
+				children,
+				direction: "ltr",
+				format: "",
+				height: 33,
+				indent: 0,
+				version: 1
+			});
+		});
+		const tdReader = (xmlNode, children) => {
+			return INodeHelper.createElementNode(TableCellNode.getType(), {
+				backgroundColor: xmlNode.getAttribute("backgroundColor") || null,
+				children,
+				colSpan: xmlNode.getAttribute("colSpan") ? parseInt(xmlNode.getAttribute("colSpan"), 10) : 1,
+				direction: "ltr",
+				format: "",
+				headerState: 0,
+				indent: 0,
+				rowSpan: xmlNode.getAttribute("rowSpan") ? parseInt(xmlNode.getAttribute("rowSpan"), 10) : 1,
+				version: 1
+			});
+		};
+		litexmlService.registerXMLReader("th", tdReader);
+		litexmlService.registerXMLReader("td", tdReader);
+	}
+	registerMarkdown() {
+		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
+		if (!markdownService) return;
+		markdownService.registerMarkdownWriter(TableNode$1.getType(), (ctx) => {
+			ctx.wrap("", "\n");
+		});
+		markdownService.registerMarkdownWriter(TableRowNode.getType(), (ctx, node) => {
+			const parent = node.getParent();
+			if (!$isTableNode(parent)) return;
+			if (!node.getPreviousSibling()) ctx.wrap("", `\n${parent.getColWidths()?.map(() => {
+				return "|:--";
+			}).join("")}|\n`);
+			else ctx.wrap("", "\n");
+		});
+		markdownService.registerMarkdownWriter(TableCellNode.getType(), (ctx, node) => {
+			ctx.addProcessor(tableCellProcessor);
+			if (!node.getNextSibling()) ctx.wrap("|", "|");
+			else ctx.wrap("|", "");
+		});
+		markdownService.registerMarkdownReader("table", (node, children) => {
+			const colLen = node.children[0]?.children.length || 1;
+			return INodeHelper.createElementNode("table", {
+				children,
+				colWidths: new Array(colLen).fill(750 / colLen),
+				direction: null,
+				format: "",
+				indent: 0,
+				version: 1
+			});
+		});
+		markdownService.registerMarkdownReader("tableRow", (_node, children) => {
+			return INodeHelper.createElementNode("tablerow", {
+				children,
+				direction: "ltr",
+				format: "",
+				height: 33,
+				indent: 0,
+				version: 1
+			});
+		});
+		markdownService.registerMarkdownReader("tableCell", (_node, children) => {
+			return INodeHelper.createElementNode("tablecell", {
+				backgroundColor: null,
+				children,
+				colSpan: 1,
+				direction: "ltr",
+				format: "",
+				headerState: 0,
+				indent: 0,
+				rowSpan: 1,
+				version: 1
+			});
+		});
+	}
+};
+//#endregion
+//#region src/headless/plugins/codeblock.ts
+init_helper();
+init_plugin();
+const createCodeChildren = (code) => code.split("\n").flatMap((text, index, array) => {
+	const textNode = INodeHelper.createTextNode(text);
+	textNode.type = "code-highlight";
+	if (index === array.length - 1) return textNode;
+	return [textNode, {
+		type: "linebreak",
+		version: 1
+	}];
+}).flat();
+const HeadlessCodeblockPlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "HeadlessCodeblockPlugin";
+	}
+	constructor(kernel) {
+		super();
+		this.kernel = kernel;
+		kernel.registerNodes([CodeNode, CodeHighlightNode]);
+		kernel.registerThemes({ code: "editor-code" });
+	}
+	onInit() {
+		this.registerMarkdown();
+		this.registerLiteXml();
+	}
+	registerLiteXml() {
+		const litexmlService = this.kernel.requireService(ILitexmlService);
+		if (!litexmlService) return;
+		litexmlService.registerXMLWriter(CodeNode.getType(), (node, ctx) => {
+			const codeNode = node;
+			return ctx.createXmlNode("code", { lang: codeNode.getLanguage() || "plaintext" }, codeNode.getTextContent());
+		});
+		litexmlService.registerXMLReader("code", (xmlElement, children) => {
+			const text = children.map((value) => value.text || "").join("");
+			return INodeHelper.createElementNode(CodeNode.getType(), {
+				children: createCodeChildren(text),
+				direction: "ltr",
+				format: "",
+				indent: 0,
+				language: xmlElement.getAttribute("lang"),
+				version: 1
+			});
+		});
+	}
+	registerMarkdown() {
+		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
+		if (!markdownService) return;
+		markdownService.registerMarkdownWriter(CodeNode.getType(), (ctx, node) => {
+			if ($isCodeNode(node)) ctx.wrap("```" + (node.getLanguage() || "") + "\n", "\n```\n");
+		});
+		markdownService.registerMarkdownWriter(TabNode.getType(), (ctx) => {
+			ctx.appendLine("  ");
+		});
+		markdownService.registerMarkdownWriter(CodeHighlightNode.getType(), (ctx, node) => {
+			if ($isCodeHighlightNode(node)) ctx.appendLine(node.getTextContent());
+		});
+		markdownService.registerMarkdownWriter("linebreak", (ctx, node) => {
+			if ($isCodeNode(node.getParent())) ctx.appendLine("\n");
+		});
+		markdownService.registerMarkdownReader("code", (node) => {
+			const language = node.lang ? getCodeLanguageByInput(node.lang) : "plaintext";
+			return INodeHelper.createElementNode("code", {
+				children: createCodeChildren(node.value),
+				direction: "ltr",
+				format: "",
+				indent: 0,
+				language,
+				version: 1
+			});
+		});
+	}
+};
+//#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 textNode = {
+		detail: 0,
+		format: 0,
+		id: createSerializedId(context),
+		mode: "normal",
+		style: "",
+		text,
+		type: "code-highlight",
+		version: 1
+	};
+	if (index === array.length - 1) return textNode;
+	return [textNode, {
+		id: createSerializedId(context),
+		type: "linebreak",
+		version: 1
+	}];
+});
+const normalizeLegacyEditorDataNode = (node, context) => {
+	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;
+	if (record.type === "code" && typeof record.code === "string" && !Array.isArray(children)) return {
+		...record,
+		children: createCodeChildrenFromLegacyCode(record.code, context),
+		direction: record.direction ?? "ltr",
+		format: record.format ?? "",
+		indent: record.indent ?? 0,
+		language: record.language ?? "plaintext",
+		theme: record.theme ?? record.codeTheme
+	};
+	if (Array.isArray(children)) return {
+		...record,
+		children
+	};
+	return record;
+};
+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)
+	};
+};
+const DEFAULT_HEADLESS_EDITOR_PLUGINS = [
+	[CommonPlugin, { enableHotkey: false }],
+	MarkdownPlugin,
+	CodePlugin,
+	HeadlessCodeblockPlugin,
+	HRPlugin,
+	ListPlugin,
+	TablePlugin,
+	LitexmlPlugin
+];
+var HeadlessEditor = class {
+	constructor(options = {}) {
+		this.kernel = Editor.createEditor();
+		const plugins = [...options.plugins ?? DEFAULT_HEADLESS_EDITOR_PLUGINS, ...options.additionalPlugins ?? []];
+		this.kernel.registerPlugins(plugins);
+		this.kernel.initHeadlessEditor();
+		if (options.initialValue) this.hydrate(options.initialValue);
+	}
+	hydrate(input) {
+		this.kernel.setDocument(input.type, input.content, input.options);
+		return this;
+	}
+	hydrateEditorData(editorData, options) {
+		this.kernel.setDocument("json", normalizeLegacyEditorData(editorData), options);
+		return this;
+	}
+	hydrateLiteXML(litexml, options) {
+		this.kernel.setDocument("litexml", litexml, options);
+		return this;
+	}
+	hydrateMarkdown(markdown, options) {
+		this.kernel.setDocument("markdown", markdown, options);
+		return this;
+	}
+	async applyLiteXML(operation) {
+		const operations = Array.isArray(operation) ? operation : [operation];
+		for (const item of operations) this.applyLiteXMLOperation(item);
+		await moment();
+		return this;
+	}
+	async applyLiteXMLBatch(operations) {
+		this.kernel.dispatchCommand(LITEXML_MODIFY_COMMAND, operations);
+		await moment();
+		return this;
+	}
+	export(options = {}) {
+		const snapshot = {
+			editorData: this.kernel.getDocument("json"),
+			markdown: this.kernel.getDocument("markdown")
+		};
+		if (options.litexml) snapshot.litexml = this.kernel.getDocument("litexml");
+		return snapshot;
+	}
+	exportState(options) {
+		return this.export(options);
+	}
+	destroy() {
+		this.kernel.destroy();
+	}
+	applyLiteXMLOperation(operation) {
+		switch (operation.action) {
+			case "apply":
+			case "replace":
+				this.kernel.dispatchCommand(LITEXML_APPLY_COMMAND, {
+					delay: operation.delay,
+					litexml: operation.litexml
+				});
+				return;
+			case "batch":
+				this.kernel.dispatchCommand(LITEXML_MODIFY_COMMAND, operation.operations);
+				return;
+			case "insert":
+				this.kernel.dispatchCommand(LITEXML_INSERT_COMMAND, operation);
+				return;
+			case "remove":
+				this.kernel.dispatchCommand(LITEXML_REMOVE_COMMAND, {
+					delay: operation.delay,
+					id: operation.id
+				});
+				return;
+		}
+	}
+};
+function createHeadlessEditor(options) {
+	return new HeadlessEditor(options);
+}
+//#endregion
+//#region src/plugins/auto-complete/plugin/index.ts
+init_helper();
+init_plugin();
+init_debug();
+const AutoCompletePlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "AutoCompletePlugin";
+	}
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		this.config = config;
+		this.logger = createDebugLogger("plugin", "auto-complete");
+		this.lastCursorPosition = null;
+		this.cursorStableTimer = null;
+		this.abortController = null;
+		this.placeholderNodes = [];
+		this.currentSuggestion = null;
+		this.markdownService = null;
+		this.delay = config?.delay ?? 1e3;
+		kernel.registerNodes([PlaceholderNode, PlaceholderBlockNode]);
+		if (config?.theme) kernel.registerThemes(config?.theme);
+	}
+	onInit(editor) {
+		this.markdownService = this.kernel.requireService(IMarkdownShortCutService);
+		if (!this.markdownService) {
+			this.logger.error("❌ MarkdownShortCutService is required for AutoCompletePlugin");
+			return;
+		}
+		this.register(editor.registerUpdateListener(({ editorState }) => {
+			editorState.read(() => {
+				if (editor.isComposing()) return;
+				const selection = $getSelection();
+				if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
+					this.clearTimer();
+					this.clearPlaceholderNodes(editor);
+					return;
+				}
+				const currentPosition = {
+					key: selection.anchor.key,
+					offset: selection.anchor.offset,
+					type: selection.anchor.type
+				};
+				if (this.hasPositionChanged(currentPosition)) {
+					this.clearTimer();
+					this.clearPlaceholderNodes(editor);
+					this.abortController = new AbortController();
+					this.cursorStableTimer = window.setTimeout(() => {
+						this.handleCursorStable(editor, currentPosition);
+					}, this.delay);
+				}
+			});
+		}));
+		this.register(editor.registerCommand(KEY_TAB_COMMAND, (event) => {
+			if (this.currentSuggestion) {
+				event?.preventDefault();
+				this.applySuggestion(editor);
+				return true;
+			}
+			return false;
+		}, COMMAND_PRIORITY_HIGH));
+		this.register(editor.registerCommand(KEY_ESCAPE_COMMAND, (event) => {
+			if (this.currentSuggestion) {
+				event?.preventDefault();
+				this.clearPlaceholderNodes(editor);
+				this.currentSuggestion = null;
+				return true;
+			}
+			return false;
+		}, COMMAND_PRIORITY_CRITICAL));
+		this.register(editor.registerTextContentListener(() => {
+			if (this.placeholderNodes.length > 0) this.clearPlaceholderNodes(editor);
+		}));
+	}
+	hasPositionChanged(currentPosition) {
+		if (!this.lastCursorPosition) return true;
+		return this.lastCursorPosition.key !== currentPosition.key || this.lastCursorPosition.offset !== currentPosition.offset || this.lastCursorPosition.type !== currentPosition.type;
+	}
+	clearTimer() {
+		this.abortController?.abort("use cancel");
+		if (this.cursorStableTimer) {
+			clearTimeout(this.cursorStableTimer);
+			this.cursorStableTimer = null;
+		}
+	}
+	handleCursorStable(editor, position) {
+		editor.getEditorState().read(() => {
+			if (editor.isComposing()) return;
+			if (!this.abortController || this.abortController.signal.aborted) return;
+			const selection = $getSelection();
+			if (!$isRangeSelection(selection) || !selection.isCollapsed()) return;
+			const currentPosition = {
+				key: selection.anchor.key,
+				offset: selection.anchor.offset,
+				type: selection.anchor.type
+			};
+			if (!this.isSamePosition(position, currentPosition)) return;
+			if (this.lastCursorPosition && this.isSamePosition(position, this.lastCursorPosition)) return;
+			this.lastCursorPosition = currentPosition;
+			const anchorNode = selection.anchor.getNode();
+			let selectionType = "unknown";
+			const textRet = this.getTextBeforeCursor(selection);
+			selectionType = anchorNode.getType();
+			if (this.config?.onAutoComplete) this.config.onAutoComplete({
+				abortSignal: this.abortController.signal,
+				afterText: textRet.textAfter,
+				editor: this.kernel,
+				input: textRet.textBefore,
+				selectionType
+			}).then((result) => {
+				let currentSelection = null;
+				editor.getEditorState().read(() => {
+					currentSelection = $getSelection();
+				});
+				if (editor.isComposing()) {
+					this.clearPlaceholderNodes(editor);
+					return;
+				}
+				if (!currentSelection || !$isRangeSelection(currentSelection) || !currentSelection.isCollapsed()) {
+					this.clearPlaceholderNodes(editor);
+					return;
+				}
+				const newPosition = {
+					key: currentSelection.anchor.key,
+					offset: currentSelection.anchor.offset,
+					type: currentSelection.anchor.type
+				};
+				if (!this.isSamePosition(currentPosition, newPosition)) {
+					this.clearPlaceholderNodes(editor);
+					return;
+				}
+				if (result) {
+					this.currentSuggestion = result;
+					this.showPlaceholderNodes(editor, result);
+					this.logger.debug("🔍 Auto-complete triggered:", {
+						afterText: textRet.textAfter,
+						input: textRet.textBefore,
+						position: currentPosition,
+						result,
+						selectionType
+					});
+				} else this.clearPlaceholderNodes(editor);
+			});
+		});
+	}
+	getTextBeforeCursor(selection) {
+		const ret = {
+			textAfter: "",
+			textBefore: ""
+		};
+		const anchorNode = selection.anchor.getNode();
+		const anchorOffset = selection.anchor.offset;
+		let paragraphNode = anchorNode;
+		while (paragraphNode && paragraphNode.isInline()) {
+			const parent = paragraphNode.getParent();
+			if (!parent) break;
+			paragraphNode = parent;
+		}
+		if (!paragraphNode) return ret;
+		this.logger.debug("🔍 Paragraph Node Type:", paragraphNode, anchorNode);
+		let founded = false;
+		const collectTextBeforeCursor = (node, targetNode, targetOffset) => {
+			if (node === targetNode) {
+				founded = true;
+				if (node.getTextContent) {
+					const nodeText = node.getTextContent();
+					return {
+						text: nodeText.slice(0, targetOffset),
+						textAfter: nodeText.slice(targetOffset)
+					};
+				}
+				return {
+					text: "",
+					textAfter: ""
+				};
+			}
+			let collectedText = "";
+			let collectedTextAfter = "";
+			if (node.getTextContent && node.getType() === "text") if (founded) collectedTextAfter += node.getTextContent();
+			else collectedText += node.getTextContent();
+			if (node.getChildren) {
+				const children = node.getChildren();
+				for (const child of children) {
+					const result = collectTextBeforeCursor(child, targetNode, targetOffset);
+					collectedTextAfter += result.textAfter;
+					collectedText += result.text;
+				}
+			}
+			return {
+				text: collectedText,
+				textAfter: collectedTextAfter
+			};
+		};
+		const result = collectTextBeforeCursor(paragraphNode, anchorNode, anchorOffset);
+		return {
+			textAfter: result.textAfter,
+			textBefore: result.text
+		};
+	}
+	showPlaceholderNodes(editor, suggestion) {
+		editor.update(() => {
+			const selection = $getSelection();
+			if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
+				this.logger.warn("⚠️ No valid selection for placeholder");
+				return;
+			}
+			if (!this.markdownService) {
+				this.logger.warn("⚠️ No valid markdown service for placeholder");
+				return;
+			}
+			const nodes = this.markdownService.parseMarkdownToLexical(suggestion);
+			if (nodes.children[0]) {
+				const firstChild = nodes.children[0];
+				firstChild.children = [{
+					children: firstChild.children,
+					type: "PlaceholderInline"
+				}];
+			}
+			for (let i = 1; i < nodes.children.length; i++) {
+				const child = nodes.children[i];
+				nodes.children[i] = {
+					children: [child],
+					type: "PlaceholderBlock"
+				};
+			}
+			const markerNode = INodeHelper.createTextNode("​");
+			nodes.children.push({
+				children: [markerNode],
+				name: "",
+				type: "PlaceholderInline"
+			});
+			const saveSel = selection.clone();
+			this.markdownService.insertIRootNode(editor, nodes, selection);
+			$setSelection(saveSel);
+		});
+	}
+	clearPlaceholderNodes(editor) {
+		editor.update(() => {
+			editor.getEditorState()._nodeMap.forEach((node) => {
+				const selection = $getSelection();
+				const clonedSelection = selection ? selection.clone() : null;
+				if (node.isAttached() && ["PlaceholderBlock", "PlaceholderInline"].includes(node.getType())) {
+					if (node.getType() === "PlaceholderInline" && node.getTextContent().includes("​") && node.getPreviousSibling() === null) {
+						while (node.getNextSibling()) {
+							const next = node.getNextSibling();
+							if (next) $insertNodes([next]);
+						}
+						$setSelection(clonedSelection);
+						node.getParent()?.remove();
+						return;
+					}
+					node.remove();
+				}
+			});
+		});
+	}
+	applySuggestion(editor) {
+		if (!this.currentSuggestion) return;
+		const markdown = this.currentSuggestion;
+		editor.update(() => {
+			const selection = $getSelection();
+			if (!$isRangeSelection(selection) || !selection.isCollapsed() || !this.markdownService) return;
+			editor.getEditorState()._nodeMap.forEach((node) => {
+				if (node.isAttached() && ["PlaceholderBlock", "PlaceholderInline"].includes(node.getType())) node.remove();
+			});
+			const nodes = this.markdownService.parseMarkdownToLexical(markdown);
+			this.markdownService.insertIRootNode(editor, nodes, selection);
+			this.clearPlaceholderNodes(editor);
+			this.currentSuggestion = null;
+		});
+	}
+	isSamePosition(pos1, pos2) {
+		return pos1.key === pos2.key && pos1.offset === pos2.offset && pos1.type === pos2.type;
+	}
+	destroy() {
+		this.clearTimer();
+		this.placeholderNodes = [];
+		super.destroy();
+	}
+};
+//#endregion
+//#region src/plugins/auto-complete/react/style.ts
+const styles$12 = createStaticStyles(({ css }) => ({
+	placeholderBlock: css`
+    opacity: 0.4;
+  `,
+	placeholderInline: css`
+    opacity: 0.4;
+  `
+}));
+//#endregion
+//#region src/plugins/auto-complete/react/ReactAutoCompletePlugin.tsx
+const ReactAutoCompletePlugin = ({ onAutoComplete, delay }) => {
+	const [editor] = useLexicalComposerContext();
+	useLayoutEffect(() => {
+		editor.registerPlugin(AutoCompletePlugin, {
+			delay,
+			onAutoComplete,
+			theme: {
+				placeholderBlock: cx(styles$12.placeholderBlock),
+				placeholderInline: cx(styles$12.placeholderInline)
+			}
+		});
+	}, []);
+	return null;
+};
+ReactAutoCompletePlugin.displayName = "ReactAutoCompletePlugin";
+//#endregion
 //#region src/plugins/code/react/style.ts
 const styles$11 = createStaticStyles(({ css, cssVar }) => ({ codeInline: css`
     display: inline;
@@ -3199,70 +4017,6 @@ const ReactFilePlugin = ({ className, locale, handleUpload, markdownWriter, them
 };
 ReactFilePlugin.displayName = "ReactFilePlugin";
 //#endregion
-//#region src/plugins/hr/command/index.ts
-const INSERT_HORIZONTAL_RULE_COMMAND = createCommand("INSERT_HORIZONTAL_RULE_COMMAND");
-function registerHorizontalRuleCommand(editor) {
-	return editor.registerCommand(INSERT_HORIZONTAL_RULE_COMMAND, () => {
-		editor.update(() => {
-			$insertNodes([$createHorizontalRuleNode()]);
-		});
-		return true;
-	}, COMMAND_PRIORITY_EDITOR);
-}
-//#endregion
-//#region src/plugins/hr/plugin/index.ts
-init_helper();
-init_plugin();
-const HRPlugin = class extends KernelPlugin {
-	static {
-		this.pluginName = "HRPlugin";
-	}
-	constructor(kernel, config) {
-		super();
-		this.kernel = kernel;
-		kernel.registerNodes([HorizontalRuleNode]);
-		kernel.registerThemes({ hr: config?.theme || "" });
-		this.registerDecorator(kernel, "horizontalrule", (node, editor) => {
-			return config?.decorator ? config.decorator(node, editor) : null;
-		});
-	}
-	onInit(editor) {
-		this.register(registerHorizontalRuleCommand(editor));
-		this.registerMarkdown();
-		this.registerLiteXml();
-	}
-	registerLiteXml() {
-		const litexmlService = this.kernel.requireService(ILitexmlService);
-		if (!litexmlService) return;
-		litexmlService.registerXMLWriter(HorizontalRuleNode.getType(), (node, ctx) => {
-			if ($isHorizontalRuleNode(node)) return ctx.createXmlNode("hr", {});
-			return false;
-		});
-		litexmlService.registerXMLReader("hr", () => {
-			return INodeHelper.createElementNode(HorizontalRuleNode.getType(), {});
-		});
-	}
-	registerMarkdown() {
-		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownShortCut({
-			regExp: /^(---|\*\*\*|___)$/,
-			replace: (parentNode, _1, _2, isImport) => {
-				const line = $createHorizontalRuleNode();
-				if (isImport || parentNode.getNextSibling()) parentNode.replace(line);
-				else parentNode.insertBefore(line);
-				line.selectNext();
-			},
-			trigger: "enter",
-			type: "element"
-		});
-		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(HorizontalRuleNode.getType(), (ctx, node) => {
-			if ($isHorizontalRuleNode(node)) ctx.appendLine("---\n\n");
-		});
-		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownReader("thematicBreak", () => {
-			return INodeHelper.createElementNode("horizontalrule", {});
-		});
-	}
-};
-//#endregion
 //#region src/plugins/hr/react/style.ts
 const styles$7 = createStaticStyles(({ css, cssVar }) => css`
     cursor: pointer;
@@ -4784,558 +5538,259 @@ const LinkToolbar = memo(({ editor, enable }) => {
 			if (!payload.event.target || divRef.current === null) return false;
 			clearTimeout(clearTimerRef.current);
 			setLinkNode(payload.linkNode);
-			updatePosition({
-				callback: () => {
-					LinkRef.current = payload.event.target;
-				},
-				floating: divRef.current,
-				offset: 4,
-				placement: "top-start",
-				reference: payload.event.target
-			});
-			return false;
-		}, COMMAND_PRIORITY_NORMAL), editor.registerCommand(HOVER_OUT_LINK_COMMAND, () => {
-			clearTimerRef.current = setTimeout(handleCancel, 300);
-			return true;
-		}, COMMAND_PRIORITY_NORMAL));
-	}, [enable, editable]);
-	return /* @__PURE__ */ jsx(ActionIconGroup, {
-		className: styles$5.linkToolbar,
-		items: [
-			{
-				icon: EditIcon,
-				key: "edit",
-				label: t("link.edit"),
-				onClick: handleEdit
-			},
-			{
-				icon: ExternalLinkIcon,
-				key: "openLink",
-				label: t("link.open"),
-				onClick: handleOpenLink
-			},
-			{
-				icon: UnlinkIcon,
-				key: "unlink",
-				label: t("link.unlink"),
-				onClick: () => {
-					handleRemove();
-					handleCancel();
-				}
-			}
-		],
-		onMouseEnter: () => {
-			clearTimeout(clearTimerRef.current);
-		},
-		onMouseLeave: () => {
-			handleCancel();
-		},
-		ref: divRef,
-		shadow: true,
-		size: {
-			blockSize: 32,
-			size: 16
-		},
-		variant: "outlined"
-	});
-});
-LinkToolbar.displayName = "LinkToolbar";
-//#endregion
-//#region src/plugins/link/react/ReactLinkPlugin.tsx
-const ReactLinkPlugin = ({ theme, enableHotkey = true, validateUrl, attributes }) => {
-	const [enableToolbar, setEnableToolbar] = useState(false);
-	const [editor] = useLexicalComposerContext();
-	useLayoutEffect(() => {
-		editor.registerPlugin(MarkdownPlugin);
-		editor.registerPlugin(LinkPlugin, {
-			attributes,
-			enableHotkey,
-			theme: theme || styles$5,
-			validateUrl
-		});
-	}, [
-		attributes,
-		enableHotkey,
-		styles$5,
-		theme,
-		validateUrl
-	]);
-	useLexicalEditor(() => {
-		const linkService = editor.requireService(ILinkService);
-		setEnableToolbar(linkService.enableLinkToolbar);
-		const handleChange = () => {
-			setEnableToolbar(linkService.enableLinkToolbar);
-		};
-		linkService.on("linkToolbarChange", handleChange);
-		return () => {
-			linkService.off("linkToolbarChange", handleChange);
-		};
-	}, []);
-	return /* @__PURE__ */ jsxs(PortalAnchor, { children: [/* @__PURE__ */ jsx(LinkToolbar, {
-		editor: editor.getLexicalEditor(),
-		enable: enableToolbar
-	}), /* @__PURE__ */ jsx(LinkEdit, { editor: editor.getLexicalEditor() })] });
-};
-ReactLinkPlugin.displayName = "ReactLinkPlugin";
-//#endregion
-//#region src/plugins/link-highlight/plugin/registry.ts
-init_hotkey();
-function registerLinkHighlight(editor, kernel, options) {
-	const { enableHotkey = true } = options || {};
-	return mergeRegister(editor.registerUpdateListener(({ mutatedNodes }) => {
-		const keys = (mutatedNodes?.get(LinkHighlightNode))?.keys() || [];
-		const needAddBefore = /* @__PURE__ */ new Set();
-		editor.getEditorState().read(() => {
-			for (const key of keys) {
-				const node = $getNodeByKey(key);
-				if (!node) return;
-				if (node.getParent()?.getFirstChild() === node) needAddBefore.add(node);
-			}
-		});
-		if (needAddBefore.size > 0) editor.update(() => {
-			needAddBefore.forEach((node) => {
-				if (!node.getPreviousSibling()) node.insertBefore($createCursorNode());
-			});
-		});
-	}), kernel.registerHotkey(HotkeyEnum.Link, () => editor.dispatchCommand(INSERT_LINK_HIGHLIGHT_COMMAND, void 0), {
-		enabled: enableHotkey,
-		preventDefault: true,
-		stopPropagation: true
-	}));
-}
-//#endregion
-//#region src/plugins/link-highlight/plugin/index.ts
-init_helper();
-init_plugin();
-init_debug();
-const LinkHighlightPlugin = class extends KernelPlugin {
-	static {
-		this.pluginName = "LinkHighlightPlugin";
-	}
-	constructor(kernel, config) {
-		super();
-		this.kernel = kernel;
-		this.config = config;
-		this.logger = createDebugLogger("plugin", "link-highlight");
-		kernel.registerNodes([LinkHighlightNode]);
-		kernel.registerThemes({ linkHighlight: config?.theme || "editor-link-highlight" });
-		this.urlRegex = config?.urlRegex || /^(?:https?:\/\/|mailto:|tel:)[^\s"<>[\\\]^`{|}]+|^www\.[^\s"<>[\\\]^`{|}]+/i;
-		this.logger.debug("LinkHighlightPlugin initialized");
-	}
-	onInit(editor) {
-		this.register(registerLinkHighlightCommand(editor));
-		this.register(registerLinkHighlight(editor, this.kernel, { enableHotkey: this.config?.enableHotkey }));
-		if (this.config?.enablePasteAutoHighlight !== false) this.register(editor.registerCommand(PASTE_COMMAND, (payload) => {
-			const { clipboardData } = payload;
-			if (clipboardData && clipboardData.types && clipboardData.types.length === 1 && clipboardData.types[0] === "text/plain") {
-				const data = clipboardData.getData("text/plain").trim();
-				if (this.urlRegex.test(data) && isValidUrl(data)) {
-					payload.stopImmediatePropagation();
-					payload.preventDefault();
-					this.logger.debug("Auto-highlighting pasted URL:", data);
-					editor.update(() => {
-						const selection = $getSelection();
-						if ($isRangeSelection(selection)) {
-							const linkHighlightNode = $createLinkHighlightNode();
-							const textNode = $createTextNode(data);
-							linkHighlightNode.append(textNode);
-							selection.insertNodes([linkHighlightNode]);
-						}
-					});
-					return true;
-				}
-			}
+			updatePosition({
+				callback: () => {
+					LinkRef.current = payload.event.target;
+				},
+				floating: divRef.current,
+				offset: 4,
+				placement: "top-start",
+				reference: payload.event.target
+			});
 			return false;
-		}, COMMAND_PRIORITY_NORMAL));
-		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
-		if (!markdownService) return;
-		markdownService.registerMarkdownWriter(LinkHighlightNode.getType(), (ctx, node) => {
-			ctx.appendLine(node.getTextContent());
+		}, COMMAND_PRIORITY_NORMAL), editor.registerCommand(HOVER_OUT_LINK_COMMAND, () => {
+			clearTimerRef.current = setTimeout(handleCancel, 300);
 			return true;
-		});
-		markdownService.registerMarkdownShortCut({
-			regExp: /<((?:https?:\/\/|mailto:|tel:|www\.)[^\s"<>[\\\]^`{|}]+)>\s?$/,
-			replace: (textNode, match) => {
-				const [, url] = match;
-				if (!url || !isValidUrl(url)) return;
-				this.logger.debug("Converting markdown auto-link to LinkHighlightNode:", url);
-				const linkHighlightNode = $createLinkHighlightNode();
-				const textNodeContent = $createTextNode(url);
-				linkHighlightNode.append(textNodeContent);
-				textNode.replace(linkHighlightNode);
+		}, COMMAND_PRIORITY_NORMAL));
+	}, [enable, editable]);
+	return /* @__PURE__ */ jsx(ActionIconGroup, {
+		className: styles$5.linkToolbar,
+		items: [
+			{
+				icon: EditIcon,
+				key: "edit",
+				label: t("link.edit"),
+				onClick: handleEdit
 			},
-			trigger: ">",
-			type: "text-match"
-		});
-		markdownService.registerMarkdownReader("html", (node) => {
-			const match = (node.value || "").match(/^<((?:https?:\/\/|mailto:|tel:|www\.)[^\s"<>[\\\]^`{|}]+)>$/);
-			if (match) {
-				const url = match[1].replaceAll(/[\u200B-\u200D\u2060\uFEFF]/g, "");
-				this.logger.debug("Converting HTML auto-link to LinkHighlightNode:", url);
-				return INodeHelper.createElementNode("linkHighlight", {
-					children: [INodeHelper.createTextNode(url, {})],
-					direction: "ltr",
-					format: "",
-					indent: 0,
-					type: "linkHighlight",
-					version: 1
-				});
-			}
-			return false;
-		}, 1);
-		markdownService.registerMarkdownReader("link", (node, children) => {
-			const url = node.url || "";
-			if (!children || children.length === 0) return false;
-			if (children.filter((child) => child.type === "text").map((child) => child.text || "").join("") === url) {
-				this.logger.debug("Converting markdown auto-link to LinkHighlightNode:", url);
-				return INodeHelper.createElementNode("linkHighlight", {
-					children: [INodeHelper.createTextNode(url, {})],
-					direction: "ltr",
-					format: "",
-					indent: 0,
-					type: "linkHighlight",
-					version: 1
-				});
+			{
+				icon: ExternalLinkIcon,
+				key: "openLink",
+				label: t("link.open"),
+				onClick: handleOpenLink
+			},
+			{
+				icon: UnlinkIcon,
+				key: "unlink",
+				label: t("link.unlink"),
+				onClick: () => {
+					handleRemove();
+					handleCancel();
+				}
 			}
-			return false;
-		}, 1);
-		this.logger.debug("LinkHighlightPlugin initialized with markdown support");
-	}
-};
-//#endregion
-//#region src/plugins/link-highlight/react/style.ts
-const styles$4 = createStaticStyles(({ css }) => {
-	return { linkHighlight: css`
-      cursor: unset;
-
-      margin-block: 1em;
-      margin-inline: 0;
-      padding: 2px;
-      border: none;
-    ` };
+		],
+		onMouseEnter: () => {
+			clearTimeout(clearTimerRef.current);
+		},
+		onMouseLeave: () => {
+			handleCancel();
+		},
+		ref: divRef,
+		shadow: true,
+		size: {
+			blockSize: 32,
+			size: 16
+		},
+		variant: "outlined"
+	});
 });
+LinkToolbar.displayName = "LinkToolbar";
 //#endregion
-//#region src/plugins/link-highlight/react/ReactLinkHighlightPlugin.tsx
-const ReactLinkHighlightPlugin = ({ className, enableHotkey = true, enablePasteAutoHighlight = true }) => {
+//#region src/plugins/link/react/ReactLinkPlugin.tsx
+const ReactLinkPlugin = ({ theme, enableHotkey = true, validateUrl, attributes }) => {
+	const [enableToolbar, setEnableToolbar] = useState(false);
 	const [editor] = useLexicalComposerContext();
 	useLayoutEffect(() => {
 		editor.registerPlugin(MarkdownPlugin);
-		editor.registerPlugin(LinkHighlightPlugin, {
+		editor.registerPlugin(LinkPlugin, {
+			attributes,
 			enableHotkey,
-			enablePasteAutoHighlight,
-			theme: cx(styles$4.linkHighlight, className)
+			theme: theme || styles$5,
+			validateUrl
 		});
 	}, [
-		className,
-		cx,
+		attributes,
 		enableHotkey,
-		enablePasteAutoHighlight,
-		editor,
-		styles$4.linkHighlight
+		styles$5,
+		theme,
+		validateUrl
 	]);
-	return null;
-};
-ReactLinkHighlightPlugin.displayName = "ReactLinkHighlightPlugin";
-//#endregion
-//#region src/plugins/list/utils/index.ts
-const LIST_INDENT_SIZE = 4;
-function getIndent(whitespaces) {
-	const tabs = whitespaces.match(/\t/g);
-	const spaces = whitespaces.match(/ /g);
-	let indent = 0;
-	if (tabs) indent += tabs.length;
-	if (spaces) indent += Math.floor(spaces.length / LIST_INDENT_SIZE);
-	return indent;
-}
-const listReplace = (listType) => {
-	return (parentNode, children, match, isImport) => {
-		const previousNode = parentNode.getPreviousSibling();
-		const nextNode = parentNode.getNextSibling();
-		const listItem = $createListItemNode(listType === "check" ? match[3] === "x" : void 0);
-		if ($isListNode(nextNode) && nextNode.getListType() === listType) {
-			const firstChild = nextNode.getFirstChild();
-			if (firstChild !== null) firstChild.insertBefore(listItem);
-			else nextNode.append(listItem);
-			parentNode.remove();
-		} else if ($isListNode(previousNode) && previousNode.getListType() === listType) {
-			previousNode.append(listItem);
-			parentNode.remove();
-		} else {
-			const list = $createListNode(listType, listType === "number" ? Number(match[2]) : void 0);
-			list.append(listItem);
-			parentNode.replace(list);
-		}
-		listItem.append(...children);
-		if (!isImport) listItem.select(0, 0);
-		const indent = getIndent(match[1]);
-		if (indent) listItem.setIndent(indent);
-	};
-};
-function $indentOverTab(selection) {
-	if ($filter(selection.getNodes(), (node) => {
-		if ($isBlockElementNode(node) && node.canIndent()) return node;
-		return null;
-	}).length > 0) return true;
-	const anchor = selection.anchor;
-	const focus = selection.focus;
-	const first = focus.isBefore(anchor) ? focus : anchor;
-	const firstBlock = $getNearestBlockElementAncestorOrThrow(first.getNode());
-	if (firstBlock.canIndent()) {
-		const firstBlockKey = firstBlock.getKey();
-		let selectionAtStart = $createRangeSelection();
-		selectionAtStart.anchor.set(firstBlockKey, 0, "element");
-		selectionAtStart.focus.set(firstBlockKey, 0, "element");
-		selectionAtStart = $normalizeSelection__EXPERIMENTAL(selectionAtStart);
-		if (selectionAtStart.anchor.is(first)) return true;
-	}
-	return false;
-}
-//#endregion
-//#region src/plugins/list/plugin/registry.ts
-init_hotkey();
-function registerListCommands(editor, kernel, options) {
-	const { enableHotkey = true } = options || {};
-	return mergeRegister(kernel.registerHotkey(HotkeyEnum.BulletList, () => editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND$1, void 0), {
-		enabled: enableHotkey,
-		preventDefault: true,
-		stopImmediatePropagation: true
-	}), kernel.registerHotkey(HotkeyEnum.NumberList, () => editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND$1, void 0), {
-		enabled: enableHotkey,
-		preventDefault: true,
-		stopImmediatePropagation: true
-	}), editor.registerCommand(KEY_TAB_COMMAND, (event) => {
-		const selection = $getSelection();
-		if (!$isRangeSelection(selection)) return false;
-		event.preventDefault();
-		const command = $indentOverTab(selection) ? event.shiftKey ? OUTDENT_CONTENT_COMMAND : INDENT_CONTENT_COMMAND : INSERT_TAB_COMMAND;
-		return editor.dispatchCommand(command, void 0);
-	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(KEY_BACKSPACE_COMMAND, (event) => {
-		const selection = $getSelection();
-		if (!$isRangeSelection(selection) || !selection.isCollapsed()) return false;
-		const anchor = selection.anchor;
-		if (anchor.offset !== 0) return false;
-		const anchorNode = anchor.getNode();
-		let listItemNode;
-		if ($isListItemNode(anchorNode)) listItemNode = anchorNode;
-		else if ($isTextNode(anchorNode)) {
-			if (anchorNode.getPreviousSibling()) return false;
-			const parent = anchorNode.getParentOrThrow();
-			if (!$isListItemNode(parent)) return false;
-			listItemNode = parent;
-		}
-		if (!listItemNode || !$isRootNode(listItemNode.getParent()?.getParent())) return false;
-		const listNode = listItemNode.getParentOrThrow();
-		queueMicrotask(() => {
-			editor.update(() => {
-				if (!listItemNode) return;
-				let newlistNode;
-				if (listItemNode.getPreviousSibling() === null) {
-					listItemNode.replace($createParagraphNode(), true).select(0, 0);
-					return;
-				}
-				let next = listItemNode.getNextSibling();
-				if (next) newlistNode = $createListNode(listNode.getListType(), listItemNode.getValue());
-				while (next && newlistNode) {
-					next.remove();
-					newlistNode.append(next);
-					next = next.getNextSibling();
-				}
-				const p = listItemNode.replace($createParagraphNode(), true);
-				p.remove();
-				listNode.insertAfter(p);
-				if (newlistNode) p.insertAfter(newlistNode);
-				p.select(0, 0);
+	useLexicalEditor(() => {
+		const linkService = editor.requireService(ILinkService);
+		setEnableToolbar(linkService.enableLinkToolbar);
+		const handleChange = () => {
+			setEnableToolbar(linkService.enableLinkToolbar);
+		};
+		linkService.on("linkToolbarChange", handleChange);
+		return () => {
+			linkService.off("linkToolbarChange", handleChange);
+		};
+	}, []);
+	return /* @__PURE__ */ jsxs(PortalAnchor, { children: [/* @__PURE__ */ jsx(LinkToolbar, {
+		editor: editor.getLexicalEditor(),
+		enable: enableToolbar
+	}), /* @__PURE__ */ jsx(LinkEdit, { editor: editor.getLexicalEditor() })] });
+};
+ReactLinkPlugin.displayName = "ReactLinkPlugin";
+//#endregion
+//#region src/plugins/link-highlight/plugin/registry.ts
+init_hotkey();
+function registerLinkHighlight(editor, kernel, options) {
+	const { enableHotkey = true } = options || {};
+	return mergeRegister(editor.registerUpdateListener(({ mutatedNodes }) => {
+		const keys = (mutatedNodes?.get(LinkHighlightNode))?.keys() || [];
+		const needAddBefore = /* @__PURE__ */ new Set();
+		editor.getEditorState().read(() => {
+			for (const key of keys) {
+				const node = $getNodeByKey(key);
+				if (!node) return;
+				if (node.getParent()?.getFirstChild() === node) needAddBefore.add(node);
+			}
+		});
+		if (needAddBefore.size > 0) editor.update(() => {
+			needAddBefore.forEach((node) => {
+				if (!node.getPreviousSibling()) node.insertBefore($createCursorNode());
 			});
 		});
-		event.stopImmediatePropagation();
-		event.preventDefault();
-		return true;
-	}, COMMAND_PRIORITY_LOW));
+	}), kernel.registerHotkey(HotkeyEnum.Link, () => editor.dispatchCommand(INSERT_LINK_HIGHLIGHT_COMMAND, void 0), {
+		enabled: enableHotkey,
+		preventDefault: true,
+		stopPropagation: true
+	}));
 }
 //#endregion
-//#region src/plugins/list/plugin/index.ts
+//#region src/plugins/link-highlight/plugin/index.ts
 init_helper();
 init_plugin();
-const ORDERED_LIST_REGEX = /^(\s*)(\d+)\.\s/;
-const UNORDERED_LIST_REGEX = /^(\s*)[*+-]\s/;
-const CHECK_LIST_REGEX = /^(\s*)(?:-\s)?\s?(\[(\s|x)?])\s/i;
-const ListPlugin = class extends KernelPlugin {
+init_debug();
+const LinkHighlightPlugin = class extends KernelPlugin {
 	static {
-		this.pluginName = "ListPlugin";
+		this.pluginName = "LinkHighlightPlugin";
 	}
 	constructor(kernel, config) {
 		super();
 		this.kernel = kernel;
 		this.config = config;
-		kernel.registerNodes([ListNode, ListItemNode]);
-		kernel.registerThemes({ list: {
-			checklist: "editor_listItemCheck",
-			listitem: "editor_listItem",
-			listitemChecked: "editor_listItemChecked",
-			listitemUnchecked: "editor_listItemUnchecked",
-			nested: { listitem: "editor_listItemNested" },
-			ol: cx("editor_listOrdered", config?.theme),
-			olDepth: [
-				"editor_listOrdered dp1",
-				"editor_listOrdered dp2",
-				"editor_listOrdered dp3",
-				"editor_listOrdered dp4",
-				"editor_listOrdered dp5"
-			],
-			ul: cx("editor_listUnordered", config?.theme)
-		} });
+		this.logger = createDebugLogger("plugin", "link-highlight");
+		kernel.registerNodes([LinkHighlightNode]);
+		kernel.registerThemes({ linkHighlight: config?.theme || "editor-link-highlight" });
+		this.urlRegex = config?.urlRegex || /^(?:https?:\/\/|mailto:|tel:)[^\s"<>[\\\]^`{|}]+|^www\.[^\s"<>[\\\]^`{|}]+/i;
+		this.logger.debug("LinkHighlightPlugin initialized");
 	}
 	onInit(editor) {
-		this.register(registerList(editor));
-		this.register(registerCheckList(editor));
-		this.register(registerListStrictIndentTransform(editor));
-		this.register(registerListCommands(editor, this.kernel, { enableHotkey: this.config?.enableHotkey }));
-		this.registerMarkdown();
-		this.registerLiteXml();
-	}
-	registerLiteXml() {
-		const litexmlService = this.kernel.requireService(ILitexmlService);
-		if (!litexmlService) return;
-		litexmlService.registerXMLWriter(ListNode.getType(), (node, ctx) => {
-			if ($isListNode(node)) {
-				const tagName = node.getListType() === "number" ? "ol" : "ul";
-				const attributes = {};
-				if (node.getListType() === "number" && node.getStart() !== 1) attributes.start = node.getStart().toString();
-				return ctx.createXmlNode(tagName, attributes);
+		this.register(registerLinkHighlightCommand(editor));
+		this.register(registerLinkHighlight(editor, this.kernel, { enableHotkey: this.config?.enableHotkey }));
+		if (this.config?.enablePasteAutoHighlight !== false) this.register(editor.registerCommand(PASTE_COMMAND, (payload) => {
+			const { clipboardData } = payload;
+			if (clipboardData && clipboardData.types && clipboardData.types.length === 1 && clipboardData.types[0] === "text/plain") {
+				const data = clipboardData.getData("text/plain").trim();
+				if (this.urlRegex.test(data) && isValidUrl(data)) {
+					payload.stopImmediatePropagation();
+					payload.preventDefault();
+					this.logger.debug("Auto-highlighting pasted URL:", data);
+					editor.update(() => {
+						const selection = $getSelection();
+						if ($isRangeSelection(selection)) {
+							const linkHighlightNode = $createLinkHighlightNode();
+							const textNode = $createTextNode(data);
+							linkHighlightNode.append(textNode);
+							selection.insertNodes([linkHighlightNode]);
+						}
+					});
+					return true;
+				}
 			}
 			return false;
-		});
-		litexmlService.registerXMLWriter(ListItemNode.getType(), (node, ctx) => {
-			if ($isListItemNode(node)) return ctx.createXmlNode("li");
-			return false;
-		});
-		litexmlService.registerXMLReader("ol", (xmlNode, children) => {
-			return INodeHelper.createElementNode("list", {
-				children,
-				direction: "ltr",
-				format: "",
-				indent: 0,
-				listType: "number",
-				start: xmlNode.getAttribute("start") ? parseInt(xmlNode.getAttribute("start"), 10) : 1,
-				tag: "ol",
-				version: 1
-			});
-		});
-		litexmlService.registerXMLReader("ul", (xmlNode, children) => {
-			return INodeHelper.createElementNode("list", {
-				children,
-				direction: "ltr",
-				format: "",
-				indent: 0,
-				listType: "bullet",
-				start: 1,
-				tag: "ul",
-				version: 1
-			});
-		});
-		litexmlService.registerXMLReader("li", (xmlNode, children) => {
-			return INodeHelper.createElementNode("listitem", {
-				children,
-				direction: "ltr",
-				format: "",
-				indent: 0,
-				type: "listitem",
-				version: 1
-			});
-		});
-	}
-	registerMarkdown() {
+		}, COMMAND_PRIORITY_NORMAL));
 		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
 		if (!markdownService) return;
-		markdownService.registerMarkdownShortCut({
-			regExp: UNORDERED_LIST_REGEX,
-			replace: listReplace("bullet"),
-			type: "element"
-		});
-		markdownService.registerMarkdownShortCut({
-			regExp: ORDERED_LIST_REGEX,
-			replace: listReplace("number"),
-			type: "element"
+		markdownService.registerMarkdownWriter(LinkHighlightNode.getType(), (ctx, node) => {
+			ctx.appendLine(node.getTextContent());
+			return true;
 		});
 		markdownService.registerMarkdownShortCut({
-			regExp: CHECK_LIST_REGEX,
-			replace: listReplace("check"),
-			type: "element"
-		});
-		markdownService.registerMarkdownWriter(ListNode.getType(), (ctx, node) => {
-			if ($isListNode(node)) ctx.wrap("", "\n");
-		});
-		const getLevel = (node) => {
-			if (!node) return 0;
-			if ($isRootNode(node.getParent())) return 0;
-			const parent = node.getParent();
-			if (!parent) return 0;
-			return getLevel($getNearestNodeOfType(parent, ListNode)) + 1;
-		};
-		markdownService.registerMarkdownWriter(ListItemNode.getType(), (ctx, node) => {
-			const parent = node.getParent();
-			if ($isListItemNode(node) && $isListNode(parent)) {
-				if ($isListNode(node.getFirstChild())) return;
-				const level = getLevel(parent);
-				const prefix = "    ".repeat(level);
-				switch (parent.getListType()) {
-					case "bullet":
-						ctx.wrap(prefix + "- ", "\n");
-						break;
-					case "number":
-						ctx.wrap(`${prefix}${node.getValue()}. `, "\n");
-						break;
-					case "check":
-						ctx.wrap(`${prefix}- [${node.getChecked() ? "x" : " "}] `, "\n");
-						break;
-					default: break;
-				}
-			}
-		});
-		markdownService.registerMarkdownReader("list", (node, children) => {
-			const isCheck = node.children?.[0]?.type === "listItem" && typeof node.children?.[0]?.checked === "boolean";
-			let start = node.start || 1;
-			return INodeHelper.createElementNode("list", {
-				children: children.map((v) => {
-					if (v.type === "listitem") v.value = start++;
-					return v;
-				}),
-				direction: "ltr",
-				format: "",
-				indent: 0,
-				listType: isCheck ? "check" : node.ordered ? "number" : "bullet",
-				start: node.start || 1,
-				tag: node.ordered ? "ol" : "ul",
-				version: 1
-			});
+			regExp: /<((?:https?:\/\/|mailto:|tel:|www\.)[^\s"<>[\\\]^`{|}]+)>\s?$/,
+			replace: (textNode, match) => {
+				const [, url] = match;
+				if (!url || !isValidUrl(url)) return;
+				this.logger.debug("Converting markdown auto-link to LinkHighlightNode:", url);
+				const linkHighlightNode = $createLinkHighlightNode();
+				const textNodeContent = $createTextNode(url);
+				linkHighlightNode.append(textNodeContent);
+				textNode.replace(linkHighlightNode);
+			},
+			trigger: ">",
+			type: "text-match"
 		});
-		markdownService.registerMarkdownReader("listItem", (node, children, index) => {
-			return children.map((v) => {
-				if (v.type === "paragraph") return INodeHelper.createElementNode("listitem", {
-					checked: typeof node.checked === "boolean" ? node.checked : void 0,
-					children: v.children,
+		markdownService.registerMarkdownReader("html", (node) => {
+			const match = (node.value || "").match(/^<((?:https?:\/\/|mailto:|tel:|www\.)[^\s"<>[\\\]^`{|}]+)>$/);
+			if (match) {
+				const url = match[1].replaceAll(/[\u200B-\u200D\u2060\uFEFF]/g, "");
+				this.logger.debug("Converting HTML auto-link to LinkHighlightNode:", url);
+				return INodeHelper.createElementNode("linkHighlight", {
+					children: [INodeHelper.createTextNode(url, {})],
 					direction: "ltr",
 					format: "",
 					indent: 0,
-					type: "listitem",
-					value: index + 1,
+					type: "linkHighlight",
 					version: 1
 				});
-				else if (v.type === "list") return INodeHelper.createElementNode("listitem", {
-					children: [v],
+			}
+			return false;
+		}, 1);
+		markdownService.registerMarkdownReader("link", (node, children) => {
+			const url = node.url || "";
+			if (!children || children.length === 0) return false;
+			if (children.filter((child) => child.type === "text").map((child) => child.text || "").join("") === url) {
+				this.logger.debug("Converting markdown auto-link to LinkHighlightNode:", url);
+				return INodeHelper.createElementNode("linkHighlight", {
+					children: [INodeHelper.createTextNode(url, {})],
 					direction: "ltr",
 					format: "",
 					indent: 0,
-					type: "listitem",
-					value: index + 1,
+					type: "linkHighlight",
 					version: 1
 				});
-				return v;
-			});
-		});
+			}
+			return false;
+		}, 1);
+		this.logger.debug("LinkHighlightPlugin initialized with markdown support");
 	}
 };
 //#endregion
+//#region src/plugins/link-highlight/react/style.ts
+const styles$4 = createStaticStyles(({ css }) => {
+	return { linkHighlight: css`
+      cursor: unset;
+
+      margin-block: 1em;
+      margin-inline: 0;
+      padding: 2px;
+      border: none;
+    ` };
+});
+//#endregion
+//#region src/plugins/link-highlight/react/ReactLinkHighlightPlugin.tsx
+const ReactLinkHighlightPlugin = ({ className, enableHotkey = true, enablePasteAutoHighlight = true }) => {
+	const [editor] = useLexicalComposerContext();
+	useLayoutEffect(() => {
+		editor.registerPlugin(MarkdownPlugin);
+		editor.registerPlugin(LinkHighlightPlugin, {
+			enableHotkey,
+			enablePasteAutoHighlight,
+			theme: cx(styles$4.linkHighlight, className)
+		});
+	}, [
+		className,
+		cx,
+		enableHotkey,
+		enablePasteAutoHighlight,
+		editor,
+		styles$4.linkHighlight
+	]);
+	return null;
+};
+ReactLinkHighlightPlugin.displayName = "ReactLinkHighlightPlugin";
+//#endregion
 //#region src/plugins/list/react/ReactListPlugin.tsx
 const ReactListPlugin = ({ enableHotkey = true }) => {
 	const [editor] = useLexicalComposerContext();
@@ -6037,233 +6492,6 @@ const ReactMathPlugin = ({ className, renderComp, theme }) => {
 };
 ReactMathPlugin.displayName = "ReactMathPlugin";
 //#endregion
-//#region src/plugins/table/command/index.ts
-const INSERT_TABLE_COMMAND = createCommand();
-const SELECT_TABLE_COMMAND = createCommand();
-function registerTableCommand(editor) {
-	return mergeRegister(editor.registerCommand(INSERT_TABLE_COMMAND, ({ rows, columns, includeHeaders }) => {
-		const selection = $getSelection() || $getPreviousSelection();
-		if (!selection || !$isRangeSelection(selection)) return false;
-		if ($findTableNode(selection.anchor.getNode())) return false;
-		const anchorNode = selection.anchor.getNode();
-		const tableNode = $createTableNodeWithDimensions(Number(rows), Number(columns), includeHeaders);
-		if ($isElementNode(anchorNode) && anchorNode.isEmpty()) anchorNode.replace(tableNode);
-		else $insertNodeToNearestRoot(tableNode);
-		const firstDescendant = tableNode.getFirstDescendant();
-		if ($isTextNode(firstDescendant)) firstDescendant.select();
-		return true;
-	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(SELECT_TABLE_COMMAND, ({ table, columnIndex, rowIndex }) => {
-		editor.update(() => {
-			const prevSelection = $getSelection();
-			const tableNode = $getNodeByKey(table);
-			if (!tableNode || !$isTableNode(tableNode)) return;
-			const tableSelection = $isTableSelection(prevSelection) ? prevSelection : $createTableSelection();
-			if (rowIndex !== void 0) {
-				const firstRow = tableNode.getChildren()[rowIndex];
-				if (!firstRow) return;
-				const firstCell = firstRow.getFirstChild();
-				const lastCell = firstRow.getLastChild();
-				if (!firstCell || !lastCell) return;
-				tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
-				$setSelection(tableSelection);
-			} else if (columnIndex !== void 0) {
-				const firstRow = tableNode.getFirstChild();
-				const lastRow = tableNode.getLastChild();
-				if (!firstRow || !lastRow) return;
-				const firstCell = firstRow.getChildren()[columnIndex];
-				const lastCell = lastRow.getChildren()[columnIndex];
-				if (!firstCell || !lastCell) return;
-				tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
-				$setSelection(tableSelection);
-			} else {
-				const firstRow = tableNode.getFirstChild();
-				const lastRow = tableNode.getLastChild();
-				if (!firstRow || !lastRow) return;
-				const firstCell = firstRow.getFirstChild();
-				const lastCell = lastRow.getLastChild();
-				if (!firstCell || !lastCell) return;
-				tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
-				$setSelection(tableSelection);
-			}
-		});
-		return false;
-	}, COMMAND_PRIORITY_EDITOR));
-}
-//#endregion
-//#region src/plugins/table/node/index.ts
-const OriginalCreateDOM = TableNode.prototype.createDOM;
-function patchTableNode() {
-	Object.defineProperty(TableNode.prototype, "createDOM", {
-		configurable: true,
-		enumerable: false,
-		value: function(config, editor) {
-			const table = OriginalCreateDOM.call(this, config, editor);
-			const controller = document.createElement("div");
-			table.append(controller);
-			return table;
-		},
-		writable: true
-	});
-}
-//#endregion
-//#region src/plugins/table/plugin/index.ts
-init_helper();
-init_plugin();
-const tableCellProcessor = (before, content, after) => {
-	return before + content.replace(/\n+$/, "").replaceAll(/\n+/g, "<br />") + after;
-};
-const TablePlugin = class extends KernelPlugin {
-	static {
-		this.pluginName = "TablePlugin";
-	}
-	constructor(kernel, options) {
-		super();
-		this.kernel = kernel;
-		patchTableNode();
-		kernel.registerNodes([
-			TableNode$1,
-			TableRowNode,
-			TableCellNode
-		]);
-		kernel.registerThemes({
-			table: "editor_table",
-			tableCell: "editor_table_cell",
-			tableCellHeader: "editor_table_cell_header",
-			tableCellSelected: "editor_table_cell_selected",
-			tableScrollableWrapper: cx("editor_table_scrollable_wrapper", options?.theme)
-		});
-	}
-	onInit(editor) {
-		setScrollableTablesActive(editor, true);
-		this.register(registerTablePlugin(editor));
-		this.register(registerTableSelectionObserver(editor));
-		this.register(registerTableCellUnmergeTransform(editor));
-		this.register(registerTableCommand(editor));
-		this.registerMarkdown();
-		this.registerLiteXml();
-	}
-	registerLiteXml() {
-		const litexmlService = this.kernel.requireService(ILitexmlService);
-		if (!litexmlService) return;
-		litexmlService.registerXMLWriter(TableNode$1.getType(), (node, ctx) => {
-			if ($isTableNode(node)) {
-				const attributes = {};
-				const colWidths = node.getColWidths();
-				if (colWidths && colWidths.length > 0) attributes.colWidths = colWidths.join(",");
-				return ctx.createXmlNode("table", attributes);
-			}
-			return false;
-		});
-		litexmlService.registerXMLWriter(TableRowNode.getType(), (node, ctx) => {
-			if (node instanceof TableRowNode) return ctx.createXmlNode("tr", {});
-			return false;
-		});
-		litexmlService.registerXMLWriter(TableCellNode.getType(), (node, ctx) => {
-			if (node instanceof TableCellNode) {
-				const attributes = {};
-				if (node.getColSpan() > 1) attributes.colSpan = node.getColSpan().toString();
-				if (node.getRowSpan() > 1) attributes.rowSpan = node.getRowSpan().toString();
-				if (node.getBackgroundColor()) attributes.backgroundColor = node.getBackgroundColor();
-				return ctx.createXmlNode("td", attributes);
-			}
-			return false;
-		});
-		litexmlService.registerXMLReader("table", (xmlNode, children) => {
-			const colWidthsAttr = xmlNode.getAttribute("colWidths");
-			const colWidths = colWidthsAttr ? colWidthsAttr.split(",").map((width) => parseInt(width, 10)) : [];
-			let maxTdlen = 1;
-			for (const child of children) if ((child.children?.length || -1) > maxTdlen) maxTdlen = child.children.length;
-			return INodeHelper.createElementNode(TableNode$1.getType(), {
-				children,
-				colWidths: colWidths.length > 0 ? colWidths : new Array(maxTdlen).fill(750 / maxTdlen),
-				direction: null,
-				format: "",
-				indent: 0,
-				version: 1
-			});
-		});
-		litexmlService.registerXMLReader("tr", (_xmlNode, children) => {
-			return INodeHelper.createElementNode(TableRowNode.getType(), {
-				children,
-				direction: "ltr",
-				format: "",
-				height: 33,
-				indent: 0,
-				version: 1
-			});
-		});
-		const tdReader = (xmlNode, children) => {
-			return INodeHelper.createElementNode(TableCellNode.getType(), {
-				backgroundColor: xmlNode.getAttribute("backgroundColor") || null,
-				children,
-				colSpan: xmlNode.getAttribute("colSpan") ? parseInt(xmlNode.getAttribute("colSpan"), 10) : 1,
-				direction: "ltr",
-				format: "",
-				headerState: 0,
-				indent: 0,
-				rowSpan: xmlNode.getAttribute("rowSpan") ? parseInt(xmlNode.getAttribute("rowSpan"), 10) : 1,
-				version: 1
-			});
-		};
-		litexmlService.registerXMLReader("th", tdReader);
-		litexmlService.registerXMLReader("td", tdReader);
-	}
-	registerMarkdown() {
-		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
-		if (!markdownService) return;
-		markdownService.registerMarkdownWriter(TableNode$1.getType(), (ctx) => {
-			ctx.wrap("", "\n");
-		});
-		markdownService.registerMarkdownWriter(TableRowNode.getType(), (ctx, node) => {
-			const parent = node.getParent();
-			if (!$isTableNode(parent)) return;
-			if (!node.getPreviousSibling()) ctx.wrap("", `\n${parent.getColWidths()?.map(() => {
-				return "|:--";
-			}).join("")}|\n`);
-			else ctx.wrap("", "\n");
-		});
-		markdownService.registerMarkdownWriter(TableCellNode.getType(), (ctx, node) => {
-			ctx.addProcessor(tableCellProcessor);
-			if (!node.getNextSibling()) ctx.wrap("|", "|");
-			else ctx.wrap("|", "");
-		});
-		markdownService.registerMarkdownReader("table", (node, children) => {
-			const colLen = node.children[0]?.children.length || 1;
-			return INodeHelper.createElementNode("table", {
-				children,
-				colWidths: new Array(colLen).fill(750 / colLen),
-				direction: null,
-				format: "",
-				indent: 0,
-				version: 1
-			});
-		});
-		markdownService.registerMarkdownReader("tableRow", (_node, children) => {
-			return INodeHelper.createElementNode("tablerow", {
-				children,
-				direction: "ltr",
-				format: "",
-				height: 33,
-				indent: 0,
-				version: 1
-			});
-		});
-		markdownService.registerMarkdownReader("tableCell", (_node, children) => {
-			return INodeHelper.createElementNode("tablecell", {
-				backgroundColor: null,
-				children,
-				colSpan: 1,
-				direction: "ltr",
-				format: "",
-				headerState: 0,
-				indent: 0,
-				rowSpan: 1,
-				version: 1
-			});
-		});
-	}
-};
-//#endregion
 //#region src/plugins/table/utils/index.ts
 init_utils();
 function $forEachTableCell(grid, cb) {
@@ -7608,4 +7836,4 @@ function disableHotReload() {
 	}
 }
 //#endregion
-export { $closest, $closestNodeType, $createCursorNode, $getNearestNodeFromDOMNode, $getNodeFromDOMNode, $isCardLikeElementNode, $isCursorNode, AutoCompletePlugin, CardLikeElementNode, CodePlugin, CodeblockPlugin, CodemirrorPlugin, CommonPlugin, DOM_DOCUMENT_FRAGMENT_TYPE, DOM_DOCUMENT_TYPE, DOM_ELEMENT_TYPE, DOM_TEXT_TYPE, DataSource, DiffAction, EDITOR_THEME_KEY, FilePlugin, GET_MARKDOWN_SELECTION_COMMAND, HIDE_TOOLBAR_COMMAND, HOVER_COMMAND, HRPlugin, HotkeyEnum, HotkeyScopeEnum, ILinkService, ILitexmlService, IMarkdownShortCutService, INSERT_CHECK_LIST_COMMAND, INSERT_CODEINLINE_COMMAND, INSERT_CODEMIRROR_COMMAND, INSERT_FILE_COMMAND, INSERT_HEADING_COMMAND, INSERT_HORIZONTAL_RULE_COMMAND, INSERT_IMAGE_COMMAND, INSERT_LINK_COMMAND, INSERT_LINK_HIGHLIGHT_COMMAND, INSERT_MARKDOWN_COMMAND, INSERT_MATH_COMMAND, INSERT_MENTION_COMMAND, INSERT_ORDERED_LIST_COMMAND, INSERT_QUOTE_COMMAND, INSERT_TABLE_COMMAND, INSERT_UNORDERED_LIST_COMMAND, INodePlugin, INodeService, IUploadService, ImagePlugin, Kernel, KeyEnum, LITEXML_APPLY_COMMAND, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND, LexicalErrorBoundary, LexicalPortalContainer, LinkHighlightPlugin, LinkPlugin, ListPlugin, LitexmlDataSource, LitexmlPlugin, LitexmlService, MARKDOWN_READER_LEVEL_HIGH, MARKDOWN_READER_LEVEL_NORMAL, MARKDOWN_WRITER_LEVEL_MAX, MarkdownPlugin, MathPlugin, MentionPlugin, REMOVE_LIST_COMMAND, ReactAutoCompletePlugin, ReactCodePlugin, ReactCodeblockPlugin, ReactCodemirrorPlugin, ReactEditor, ReactEditorContent, ReactFilePlugin, ReactHRPlugin, ReactImagePlugin, ReactLinkHighlightPlugin, ReactLinkPlugin, ReactListPlugin, ReactLiteXmlPlugin, ReactMarkdownPlugin, ReactMathPlugin, ReactMentionPlugin, ReactNodePlugin, ReactPlainText, ReactSlashOption, ReactSlashPlugin, ReactTablePlugin, ReactToolbarPlugin, ReactVirtualBlockPlugin, SELECT_AFTER_CODEMIRROR_COMMAND, SELECT_BEFORE_CODEMIRROR_COMMAND, SELECT_TABLE_COMMAND, SHOW_TOOLBAR_COMMAND, SlashMenu, SlashPlugin, TablePlugin, UPDATE_CODEBLOCK_LANG, UPDATE_LIST_START_COMMAND, UPLOAD_PRIORITY_HIGH, UPLOAD_PRIORITY_LOW, UPLOAD_PRIORITY_MEDIUM, UploadPlugin, VirtualBlockPlugin, assert, browserDebug, bundledLanguagesInfo, compareNodeOrder, createDebugLogger, createEmptyEditorState, cursorNodeSerialized, debugLogger, debugLoggers, detectCodeLanguage, detectLanguage, devConsole, disableHotReload, enableHotReload, genServiceId, generateEditorId, getHotkeyById, getKernelFromEditor, getKernelFromEditorConfig, getNodeKeyFromDOMNode, getParentElement, isDOMNode, isDocumentFragment, isPunctuationChar, isPureUrl, isValidUrl, moment, noop, prodSafeLogger, reconcileDecorator, registerEditorKernel, registerLinkHighlightCommand, registerToolbarCommand, resetRandomKey, scrollIntoView, unregisterEditorKernel, useHasDiffNode, useLexicalComposerContext, useLexicalEditor };
+export { $closest, $closestNodeType, $createCursorNode, $getNearestNodeFromDOMNode, $getNodeFromDOMNode, $isCardLikeElementNode, $isCursorNode, AutoCompletePlugin, CardLikeElementNode, CodePlugin, CodeblockPlugin, CodemirrorPlugin, CommonPlugin, DEFAULT_HEADLESS_EDITOR_PLUGINS, DOM_DOCUMENT_FRAGMENT_TYPE, DOM_DOCUMENT_TYPE, DOM_ELEMENT_TYPE, DOM_TEXT_TYPE, DataSource, DiffAction, EDITOR_THEME_KEY, FilePlugin, GET_MARKDOWN_SELECTION_COMMAND, HIDE_TOOLBAR_COMMAND, HOVER_COMMAND, HRPlugin, HeadlessEditor, HotkeyEnum, HotkeyScopeEnum, ILinkService, ILitexmlService, IMarkdownShortCutService, INSERT_CHECK_LIST_COMMAND, INSERT_CODEINLINE_COMMAND, INSERT_CODEMIRROR_COMMAND, INSERT_FILE_COMMAND, INSERT_HEADING_COMMAND, INSERT_HORIZONTAL_RULE_COMMAND, INSERT_IMAGE_COMMAND, INSERT_LINK_COMMAND, INSERT_LINK_HIGHLIGHT_COMMAND, INSERT_MARKDOWN_COMMAND, INSERT_MATH_COMMAND, INSERT_MENTION_COMMAND, INSERT_ORDERED_LIST_COMMAND, INSERT_QUOTE_COMMAND, INSERT_TABLE_COMMAND, INSERT_UNORDERED_LIST_COMMAND, INodePlugin, INodeService, IUploadService, ImagePlugin, Kernel, KeyEnum, LITEXML_APPLY_COMMAND, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND, LexicalErrorBoundary, LexicalPortalContainer, LinkHighlightPlugin, LinkPlugin, ListPlugin, LitexmlDataSource, LitexmlPlugin, LitexmlService, MARKDOWN_READER_LEVEL_HIGH, MARKDOWN_READER_LEVEL_NORMAL, MARKDOWN_WRITER_LEVEL_MAX, MarkdownPlugin, MathPlugin, MentionPlugin, REMOVE_LIST_COMMAND, ReactAutoCompletePlugin, ReactCodePlugin, ReactCodeblockPlugin, ReactCodemirrorPlugin, ReactEditor, ReactEditorContent, ReactFilePlugin, ReactHRPlugin, ReactImagePlugin, ReactLinkHighlightPlugin, ReactLinkPlugin, ReactListPlugin, ReactLiteXmlPlugin, ReactMarkdownPlugin, ReactMathPlugin, ReactMentionPlugin, ReactNodePlugin, ReactPlainText, ReactSlashOption, ReactSlashPlugin, ReactTablePlugin, ReactToolbarPlugin, ReactVirtualBlockPlugin, SELECT_AFTER_CODEMIRROR_COMMAND, SELECT_BEFORE_CODEMIRROR_COMMAND, SELECT_TABLE_COMMAND, SHOW_TOOLBAR_COMMAND, SlashMenu, SlashPlugin, TablePlugin, UPDATE_CODEBLOCK_LANG, UPDATE_LIST_START_COMMAND, UPLOAD_PRIORITY_HIGH, UPLOAD_PRIORITY_LOW, UPLOAD_PRIORITY_MEDIUM, UploadPlugin, VirtualBlockPlugin, assert, browserDebug, bundledLanguagesInfo, compareNodeOrder, createDebugLogger, createEmptyEditorState, createHeadlessEditor, cursorNodeSerialized, debugLogger, debugLoggers, detectCodeLanguage, detectLanguage, devConsole, disableHotReload, enableHotReload, genServiceId, generateEditorId, getHotkeyById, getKernelFromEditor, getKernelFromEditorConfig, getNodeKeyFromDOMNode, getParentElement, isDOMNode, isDocumentFragment, isPunctuationChar, isPureUrl, isValidUrl, moment, noop, prodSafeLogger, reconcileDecorator, registerEditorKernel, registerLinkHighlightCommand, registerToolbarCommand, resetRandomKey, scrollIntoView, unregisterEditorKernel, useHasDiffNode, useLexicalComposerContext, useLexicalEditor };