@lobehub/editor 4.17.1 → 4.18.0

package/es/headless.js

@@ -4,10 +4,10 @@ import { createEmptyHistoryState, registerHistory } from "@lexical/history";
 import { $computeTableMapSkipCellCheck, $createTableNodeWithDimensions, $createTableSelection, $deleteTableColumnAtSelection, $deleteTableRowAtSelection, $findTableNode, $insertTableColumnAtSelection, $insertTableRowAtSelection, $isSimpleTable, $isTableCellNode, $isTableNode, $isTableRowNode, $isTableSelection, TableCellNode, TableNode, TableNode as TableNode$1, TableRowNode, registerTableCellUnmergeTransform, registerTablePlugin, registerTableSelectionObserver, setScrollableTablesActive } from "@lexical/table";
 import { get, merge, template, templateSettings } from "es-toolkit/compat";
 import EventEmitter from "eventemitter3";
-import { $applyNodeReplacement, $caretFromPoint, $createLineBreakNode, $createNodeSelection, $createParagraphNode, $createRangeSelection, $createTextNode, $getCaretRange, $getCharacterOffsets, $getChildCaret, $getNearestNodeFromDOMNode, $getNodeByKey, $getPreviousSelection, $getRoot, $getSelection, $insertNodes, $isBlockElementNode, $isDecoratorNode, $isElementNode, $isLineBreakNode, $isNodeSelection, $isRangeSelection, $isRootNode, $isRootOrShadowRoot, $isTextNode, $isTextPointCaret, $nodesOfType, $normalizeSelection__EXPERIMENTAL, $parseSerializedNode, $setSelection, COLLABORATION_TAG, COMMAND_PRIORITY_CRITICAL, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_HIGH, COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, CONTROLLED_TEXT_INSERTION_COMMAND, COPY_COMMAND, DecoratorNode, ElementNode, FORMAT_TEXT_COMMAND, HISTORIC_TAG, HISTORY_MERGE_TAG, HISTORY_PUSH_TAG, INDENT_CONTENT_COMMAND, INSERT_LINE_BREAK_COMMAND, INSERT_PARAGRAPH_COMMAND, INSERT_TAB_COMMAND, IS_BOLD, IS_CODE, IS_ITALIC, IS_STRIKETHROUGH, IS_SUBSCRIPT, IS_SUPERSCRIPT, IS_UNDERLINE, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_LEFT_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, KEY_DOWN_COMMAND, KEY_ENTER_COMMAND, KEY_TAB_COMMAND, OUTDENT_CONTENT_COMMAND, PASTE_COMMAND, ParagraphNode, REDO_COMMAND, SELECTION_CHANGE_COMMAND, SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, TEXT_TYPE_TO_FORMAT, TabNode, TextNode, UNDO_COMMAND, createCommand, createEditor, getNearestEditorFromDOMNode, isHTMLElement, isModifierMatch, resetRandomKey, setDOMUnmanaged } from "lexical";
+import { $applyNodeReplacement, $caretFromPoint, $createLineBreakNode, $createNodeSelection, $createParagraphNode, $createRangeSelection, $createTextNode, $getCaretRange, $getCharacterOffsets, $getChildCaret, $getNearestNodeFromDOMNode, $getNodeByKey, $getPreviousSelection, $getRoot, $getSelection, $insertNodes, $isBlockElementNode, $isDecoratorNode, $isElementNode, $isLineBreakNode, $isNodeSelection, $isRangeSelection, $isRootNode, $isRootOrShadowRoot, $isTextNode, $isTextPointCaret, $nodesOfType, $normalizeSelection__EXPERIMENTAL, $parseSerializedNode, $setSelection, COLLABORATION_TAG, COMMAND_PRIORITY_CRITICAL, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_HIGH, COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, CONTROLLED_TEXT_INSERTION_COMMAND, COPY_COMMAND, DecoratorNode, ElementNode, FORMAT_TEXT_COMMAND, HISTORIC_TAG, HISTORY_MERGE_TAG, HISTORY_PUSH_TAG, INDENT_CONTENT_COMMAND, INSERT_LINE_BREAK_COMMAND, INSERT_PARAGRAPH_COMMAND, INSERT_TAB_COMMAND, IS_BOLD, IS_CODE, IS_ITALIC, IS_STRIKETHROUGH, IS_SUBSCRIPT, IS_SUPERSCRIPT, IS_UNDERLINE, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_LEFT_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, KEY_DOWN_COMMAND, KEY_ENTER_COMMAND, KEY_TAB_COMMAND, OUTDENT_CONTENT_COMMAND, PASTE_COMMAND, ParagraphNode, REDO_COMMAND, SELECTION_CHANGE_COMMAND, SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, TEXT_TYPE_TO_FORMAT, TextNode, UNDO_COMMAND, createCommand, createEditor, getNearestEditorFromDOMNode, isHTMLElement, isModifierMatch, resetRandomKey, setDOMUnmanaged } from "lexical";
 import { $createHeadingNode, $createQuoteNode, $isHeadingNode, $isQuoteNode, HeadingNode, QuoteNode, registerRichText } from "@lexical/rich-text";
 import createDebug from "debug";
-import { $filter, $findMatchingParent, $getNearestBlockElementAncestorOrThrow, $getNearestNodeOfType, $insertNodeToNearestRoot, CAN_USE_DOM, IS_APPLE as isApple, addClassNamesToElement, calculateZoomLevel, isHTMLAnchorElement, isHTMLElement as isHTMLElement$1, mergeRegister } from "@lexical/utils";
+import { $filter, $findMatchingParent, $getNearestBlockElementAncestorOrThrow, $getNearestNodeOfType, $insertNodeToNearestRoot, $wrapNodeInElement, CAN_USE_DOM, IS_APPLE as isApple, addClassNamesToElement, calculateZoomLevel, isHTMLAnchorElement, isHTMLElement as isHTMLElement$1, mergeRegister } from "@lexical/utils";
 import { $isAtNodeEnd, $setBlocksType } from "@lexical/selection";
 import { registerDragonSupport } from "@lexical/dragon";
 import { $createListItemNode, $createListNode, $insertList, $isListItemNode, $isListNode, INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, ListItemNode, ListNode, registerList, registerListStrictIndentTransform } from "@lexical/list";
@@ -17,8 +17,7 @@ import remarkCjkFriendly from "remark-cjk-friendly";
 import remarkGfm from "remark-gfm";
 import remarkMath from "remark-math";
 import { $getClipboardDataFromSelection, setLexicalClipboardDataTransfer } from "@lexical/clipboard";
-import { $isCodeHighlightNode, $isCodeNode, CodeHighlightNode, CodeNode } from "@lexical/code-core";
-import { bundledLanguagesInfo } from "shiki";
+import { $isCodeHighlightNode, $isCodeNode } from "@lexical/code-core";
 //#region src/locale/index.ts
 var locale_default = {
 	block: {
@@ -594,7 +593,7 @@ const isHotkeyMatch = (event, hotkey) => {
 };
 //#endregion
 //#region src/utils/hotkey/registerHotkey.ts
-const logger$7 = createDebugLogger("hotkey");
+const logger$9 = createDebugLogger("hotkey");
 const registerHotkey = (hotkey, callback, options = {}) => {
 	return (e) => {
 		if (!isHotkeyMatch(e, hotkey.keys)) return false;
@@ -606,7 +605,7 @@ const registerHotkey = (hotkey, callback, options = {}) => {
 			...keys,
 			scopes: hotkey.scopes
 		});
-		logger$7.debug(`⌨️ Hotkey matched: ${hotkey.id} [${hotkey.keys}]`, hotkey);
+		logger$9.debug(`⌨️ Hotkey matched: ${hotkey.id} [${hotkey.keys}]`, hotkey);
 		return true;
 	};
 };
@@ -1423,7 +1422,7 @@ function registerCommands(editor) {
 }
 //#endregion
 //#region src/plugins/common/node/cursor.ts
-const logger$6 = createDebugLogger("common", "cursor");
+const logger$8 = createDebugLogger("common", "cursor");
 var CardLikeElementNode = class extends ElementNode {
 	isCardLike() {
 		return true;
@@ -1462,7 +1461,7 @@ function registerCursorNode(editor) {
 			const needAddCursor = [];
 			for (const [kClass, nodeMaps] of mutatedNodes) if (DecoratorNode.prototype.isPrototypeOf(kClass.prototype)) for (const [key, mutation] of nodeMaps) {
 				const node = $getNodeByKey(key);
-				logger$6.debug("🎭 DecoratorNode mutated:", node?.getType(), mutation, node);
+				logger$8.debug("🎭 DecoratorNode mutated:", node?.getType(), mutation, node);
 				if (mutation === "created" && node?.isInline() && node.getNextSibling() === null) needAddCursor.push(node);
 			}
 			if (needAddCursor.length > 0) editor.update(() => {
@@ -1564,7 +1563,7 @@ function registerCursorNode(editor) {
 			$setSelection(sel);
 			return true;
 		} catch (error) {
-			logger$6.error("❌ Cursor selection error:", error);
+			logger$8.error("❌ Cursor selection error:", error);
 		}
 		else if ($isCursorNode(focusNode)) try {
 			const { key: anchorKey, offset: anchorOffset, type: anchorType } = selection.anchor;
@@ -1575,7 +1574,7 @@ function registerCursorNode(editor) {
 			$setSelection(sel);
 			return true;
 		} catch (error) {
-			logger$6.error("❌ Cursor navigation error:", error);
+			logger$8.error("❌ Cursor navigation error:", error);
 		}
 		return false;
 	}, COMMAND_PRIORITY_HIGH), editor.registerCommand(KEY_ARROW_RIGHT_COMMAND, (event) => {
@@ -1754,7 +1753,7 @@ function charToId(char) {
 }
 //#endregion
 //#region src/plugins/litexml/command/index.ts
-const logger$5 = createDebugLogger("plugin", "litexml");
+const logger$7 = createDebugLogger("plugin", "litexml");
 function toArrayXml(litexml) {
 	return Array.isArray(litexml) ? litexml : [litexml];
 }
@@ -1766,7 +1765,7 @@ function tryParseChild(child, editor) {
 			oldNode
 		};
 	} catch (error) {
-		logger$5.error("❌ Error parsing child node:", error);
+		logger$7.error("❌ Error parsing child node:", error);
 		return {
 			newNode: null,
 			oldNode: null
@@ -1875,12 +1874,12 @@ function registerLiteXMLCommand(editor, dataSource) {
 							delay: true
 						}, dataSource);
 						break;
-					default: logger$5.warn(`⚠️ Unknown action type: ${action}`);
+					default: logger$7.warn(`⚠️ Unknown action type: ${action}`);
 				}
 			});
 			return false;
 		} catch (error) {
-			logger$5.error("❌ Error processing LITEXML_MODIFY_COMMAND:", error);
+			logger$7.error("❌ Error processing LITEXML_MODIFY_COMMAND:", error);
 			return false;
 		}
 	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_APPLY_COMMAND, (payload) => {
@@ -1905,9 +1904,9 @@ function handleModify(editor, dataSource, arrayXml, delay) {
 				try {
 					const { oldNode, newNode } = tryParseChild(child, editor);
 					if (oldNode && newNode) handleReplaceForApplyDelay(oldNode, newNode, modifyBlockNodes, diffNodeMap, editor);
-					else logger$5.warn(`⚠️ Node with key ${child.id} not found for diffing.`);
+					else logger$7.warn(`⚠️ Node with key ${child.id} not found for diffing.`);
 				} catch (error) {
-					logger$5.error("❌ Error replacing node:", error);
+					logger$7.error("❌ Error replacing node:", error);
 				}
 			});
 		});
@@ -1931,7 +1930,7 @@ function handleModify(editor, dataSource, arrayXml, delay) {
 					} else prevNode = prevNode.insertAfter(newNode);
 					else $insertNodes([newNode]);
 				} catch (error) {
-					logger$5.error("❌ Error replacing node:", error);
+					logger$7.error("❌ Error replacing node:", error);
 				}
 			});
 		});
@@ -2068,7 +2067,7 @@ function handleInsert(editor, payload, dataSource) {
 				});
 			}
 		} catch (error) {
-			logger$5.error("❌ Error inserting node:", error);
+			logger$7.error("❌ Error inserting node:", error);
 		}
 	});
 }
@@ -2164,6 +2163,39 @@ function registerLiteXMLDiffCommand(editor) {
 * Service ID for Node service
 */
 const INodeService = genServiceId("INodeService");
+/**
+* Default implementation of INodeService
+*/
+var NodeService = class {
+	constructor() {
+		this.processNodeTreeHandlers = [];
+	}
+	registerProcessNodeTree(process) {
+		this.processNodeTreeHandlers.push(process);
+	}
+	processNodeTree(inode) {
+		for (const handler of this.processNodeTreeHandlers) handler(inode);
+	}
+};
+//#endregion
+//#region src/plugins/inode/plugin/index.ts
+/**
+* LitexmlPlugin - A plugin that provides XML-based data source support
+* Allows converting between Lexical editor state and XML format
+*/
+const INodePlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "INodePlugin";
+	}
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		this.config = config;
+		const nodeService = new NodeService();
+		kernel.registerService(INodeService, nodeService);
+	}
+	onInit() {}
+};
 //#endregion
 //#region src/plugins/litexml/service/litexml-service.ts
 /**
@@ -2206,7 +2238,7 @@ var LitexmlService = class {
 };
 //#endregion
 //#region src/plugins/litexml/data-source/litexml-data-source.ts
-const logger$4 = createDebugLogger("plugin", "litexml");
+const logger$6 = createDebugLogger("plugin", "litexml");
 var IXmlWriterContext = class {
 	createXmlNode(tagName, attributes, textContent) {
 		return {
@@ -2234,7 +2266,7 @@ var LitexmlDataSource = class extends DataSource {
 		const xml = this.parseXMLString(litexml);
 		const inode = this.xmlToLexical(xml);
 		this.getService?.(INodeService)?.processNodeTree(inode);
-		logger$4.debug("Parsed XML to Lexical State:", inode);
+		logger$6.debug("Parsed XML to Lexical State:", inode);
 		return inode;
 	}
 	/**
@@ -2255,7 +2287,7 @@ var LitexmlDataSource = class extends DataSource {
 			});
 			editor.setEditorState(newState);
 		} catch (error) {
-			logger$4.error("Failed to parse XML:", error);
+			logger$6.error("Failed to parse XML:", error);
 			throw error;
 		}
 	}
@@ -2290,7 +2322,7 @@ var LitexmlDataSource = class extends DataSource {
 				return this.lexicalToXML(rootNode);
 			});
 		} catch (error) {
-			logger$4.error("Failed to export to XML:", error);
+			logger$6.error("Failed to export to XML:", error);
 			throw error;
 		}
 	}
@@ -2481,7 +2513,7 @@ var LitexmlDataSource = class extends DataSource {
 };
 //#endregion
 //#region src/plugins/markdown/utils/logger.ts
-const logger$3 = createDebugLogger("plugin", "markdown");
+const logger$5 = createDebugLogger("plugin", "markdown");
 //#endregion
 //#region src/plugins/markdown/data-source/markdown/parse.ts
 const selfClosingHtmlTags = new Set([
@@ -2574,7 +2606,7 @@ function convertMdastToLexical(node, index, ctx, markdownReaders = {}, parentTyp
 							const top = ctx.pop();
 							htmlStack.pop();
 							if (top?.tag !== tag) {
-								logger$3.warn("HTML tag mismatch:", tag);
+								logger$5.warn("HTML tag mismatch:", tag);
 								ret.push(...top?.children || []);
 								return ret;
 							}
@@ -2664,7 +2696,7 @@ function registerDefaultReaders(markdownReaders) {
 }
 function parseMarkdownToLexical(markdown, markdownReaders = {}) {
 	const ast = remark().use(remarkCjkFriendly).use(remarkMath).use([[remarkGfm, { singleTilde: false }]]).parse(markdown);
-	logger$3.debug("Parsed MDAST:", ast);
+	logger$5.debug("Parsed MDAST:", ast);
 	const ctx = new MarkdownContext(ast, markdown);
 	registerDefaultReaders(markdownReaders);
 	return convertMdastToLexical(ast, 0, ctx, markdownReaders);
@@ -2812,7 +2844,7 @@ function insertIRootNode(editor, root, selection) {
 }
 //#endregion
 //#region src/plugins/markdown/command/index.ts
-const logger$2 = createDebugLogger("plugin", "markdown");
+const logger$4 = createDebugLogger("plugin", "markdown");
 const INSERT_MARKDOWN_COMMAND = createCommand("INSERT_MARKDOWN_COMMAND");
 const GET_MARKDOWN_SELECTION_COMMAND = createCommand("GET_MARKDOWN_SELECTION_COMMAND");
 function restoreToEntry(editor, entry) {
@@ -2826,7 +2858,7 @@ const getLineNumber = (content, charIndex) => {
 function registerMarkdownCommand(editor, kernel, service) {
 	return mergeRegister(editor.registerCommand(INSERT_MARKDOWN_COMMAND, (payload) => {
 		const { markdown } = payload;
-		logger$2.debug("INSERT_MARKDOWN_COMMAND payload:", payload);
+		logger$4.debug("INSERT_MARKDOWN_COMMAND payload:", payload);
 		restoreToEntry(editor, payload.historyState);
 		setTimeout(() => {
 			editor.update(() => {
@@ -2834,11 +2866,11 @@ function registerMarkdownCommand(editor, kernel, service) {
 					const root = parseMarkdownToLexical(markdown, service.markdownReaders);
 					const selection = $getSelection();
 					const nodes = $generateNodesFromSerializedNodes(root.children);
-					logger$2.debug("INSERT_MARKDOWN_COMMAND nodes:", nodes);
+					logger$4.debug("INSERT_MARKDOWN_COMMAND nodes:", nodes);
 					$insertGeneratedNodes(editor, nodes, selection);
 					return true;
 				} catch (error) {
-					logger$2.error("Failed to handle markdown paste:", error);
+					logger$4.error("Failed to handle markdown paste:", error);
 				}
 			}, { tag: HISTORY_PUSH_TAG });
 		}, 0);
@@ -2869,8 +2901,8 @@ function registerMarkdownCommand(editor, kernel, service) {
 				const startLine = getLineNumber(markdownContent, startIndex);
 				const endLine = getLineNumber(markdownContent, endIndex);
 				payload.onResult(startLine, endLine);
-				logger$2.debug("GET_MARKDOWN_SELECTION_COMMAND markdownContent:", markdownContent);
-				logger$2.debug("GET_MARKDOWN_SELECTION_COMMAND startLine:", startLine, "endLine:", endLine);
+				logger$4.debug("GET_MARKDOWN_SELECTION_COMMAND markdownContent:", markdownContent);
+				logger$4.debug("GET_MARKDOWN_SELECTION_COMMAND startLine:", startLine, "endLine:", endLine);
 				return markdownContent;
 			} });
 		}
@@ -2930,7 +2962,7 @@ var MarkdownDataSource = class extends DataSource {
 			}).processSync(markdown);
 			return String(result);
 		} catch (error) {
-			logger$3.error("Failed to format markdown:", error);
+			logger$5.error("Failed to format markdown:", error);
 			return markdown;
 		}
 	}
@@ -2943,7 +2975,7 @@ var MarkdownDataSource = class extends DataSource {
 	read(editor, data) {
 		const inode = { root: parseMarkdownToLexical(data, this.markdownService.markdownReaders) };
 		this.getService?.(INodeService)?.processNodeTree(inode);
-		logger$3.debug("Parsed Lexical State:", inode);
+		logger$5.debug("Parsed Lexical State:", inode);
 		editor.setEditorState(editor.parseEditorState(inode));
 	}
 	write(editor, options) {
@@ -4116,6 +4148,15 @@ const DEFAULT_OPTIONS = {
 	lineNumbers: false,
 	tabSize: 2
 };
+const extractSerializedCodeText$1 = (children) => children.map((child) => {
+	if (!child || typeof child !== "object") return "";
+	const record = child;
+	if (record.type === "linebreak") return "\n";
+	if (record.type === "tab") return "	";
+	if (typeof record.text === "string") return record.text;
+	if (Array.isArray(record.children)) return extractSerializedCodeText$1(record.children);
+	return "";
+}).join("");
 function hasChildDOMNodeTag(node, tagName) {
 	for (const child of node.childNodes) {
 		if (isHTMLElement(child) && child.tagName === tagName) return true;
@@ -4138,7 +4179,7 @@ var CodeMirrorNode = class CodeMirrorNode extends DecoratorNode {
 	}
 	static importJSON(serializedNode) {
 		let code = serializedNode.code;
-		if ("children" in serializedNode) code = serializedNode.children?.map((child) => child.text).join("") || "";
+		if ("children" in serializedNode && Array.isArray(serializedNode.children)) code = extractSerializedCodeText$1(serializedNode.children);
 		return $createCodeMirrorNode(serializedNode.language, code, serializedNode.codeTheme, serializedNode.options).updateFromJSON(serializedNode);
 	}
 	static importDOM() {
@@ -4301,6 +4342,9 @@ function $convertPreElement(domNode) {
 	const codeTheme = domNode.getAttribute(THEME_DATA_ATTRIBUTE) || "";
 	return { node: $createCodeMirrorNode(language || "plain", domNode.textContent || "", codeTheme) };
 }
+function $isCodeMirrorNode(node) {
+	return node.getType() === CodeMirrorNode.getType();
+}
 function convertCodeNoop() {
 	return { node: null };
 }
@@ -4364,7 +4408,7 @@ function runPasteHandlers(ctx, handlers) {
 }
 //#endregion
 //#region src/plugins/common/plugin/register.ts
-const logger$1 = createDebugLogger("plugin", "common");
+const logger$3 = createDebugLogger("plugin", "common");
 function resolveElement(element, isBackward, focusOffset) {
 	const parent = element.getParent();
 	let offset = focusOffset;
@@ -4465,7 +4509,7 @@ function registerRichKeydown(editor, kernel, options) {
 				selection.insertText(text);
 			});
 		} catch (error) {
-			logger$1.error("❌ Failed to paste as plain text:", error);
+			logger$3.error("❌ Failed to paste as plain text:", error);
 		}
 	}, {
 		enabled: enableHotkey,
@@ -4974,12 +5018,12 @@ const CommonPlugin = class extends KernelPlugin {
 };
 //#endregion
 //#region src/plugins/code/node/code.ts
-var CodeNode$1 = class CodeNode$1 extends CardLikeElementNode {
+var CodeNode = class CodeNode extends CardLikeElementNode {
 	static getType() {
 		return "codeInline";
 	}
 	static clone(node) {
-		return new CodeNode$1(node.__key);
+		return new CodeNode(node.__key);
 	}
 	static importJSON(serializedNode) {
 		return $createCodeNode().updateFromJSON(serializedNode);
@@ -5021,14 +5065,14 @@ var CodeNode$1 = class CodeNode$1 extends CardLikeElementNode {
 	}
 };
 function $createCodeNode(textContent) {
-	const codeNode = $applyNodeReplacement(new CodeNode$1());
+	const codeNode = $applyNodeReplacement(new CodeNode());
 	const cursorNode = $createCursorNode();
 	codeNode.append(cursorNode);
 	if (textContent) codeNode.append($createTextNode(textContent));
 	return codeNode;
 }
 function $isCodeInlineNode(node) {
-	return node instanceof CodeNode$1;
+	return node instanceof CodeNode;
 }
 function getCodeInlineNode(node) {
 	if ($isCursorNode(node)) {
@@ -5071,7 +5115,7 @@ function registerCodeInlineCommand(editor) {
 function registerCodeInline(editor, kernel, options) {
 	const { enableHotkey = true } = options || {};
 	return mergeRegister(editor.registerUpdateListener(({ mutatedNodes }) => {
-		const keys = (mutatedNodes?.get(CodeNode$1))?.keys() || [];
+		const keys = (mutatedNodes?.get(CodeNode))?.keys() || [];
 		const needAddBefore = /* @__PURE__ */ new Set();
 		editor.getEditorState().read(() => {
 			for (const key of keys) {
@@ -5101,7 +5145,7 @@ const CodePlugin = class extends KernelPlugin {
 		super();
 		this.kernel = kernel;
 		this.config = config;
-		kernel.registerNodes([CodeNode$1]);
+		kernel.registerNodes([CodeNode]);
 		kernel.registerThemes({ codeInline: config?.theme || "editor-code" });
 	}
 	onInit(editor) {
@@ -5116,23 +5160,23 @@ const CodePlugin = class extends KernelPlugin {
 	registerLiteXml() {
 		const litexmlService = this.kernel.requireService(ILitexmlService);
 		if (!litexmlService) return;
-		litexmlService.registerXMLWriter(CodeNode$1.getType(), (node, ctx) => {
+		litexmlService.registerXMLWriter(CodeNode.getType(), (node, ctx) => {
 			return ctx.createXmlNode("codeInline", {});
 		});
 		litexmlService.registerXMLReader("codeInline", (xmlElement, children) => {
-			return INodeHelper.createElementNode(CodeNode$1.getType(), { children });
+			return INodeHelper.createElementNode(CodeNode.getType(), { children });
 		});
 	}
 	registerMarkdown() {
 		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
 		if (!markdownService) return;
-		markdownService.registerMarkdownWriter(CodeNode$1.getType(), (ctx, node) => {
+		markdownService.registerMarkdownWriter(CodeNode.getType(), (ctx, node) => {
 			ctx.appendLine(`\`${node.getTextContent().replaceAll("", "")}\``);
 			return true;
 		});
 		markdownService.registerMarkdownShortCuts([{
 			process: (selection) => {
-				if (selection.getNodes().some((node) => node.getType() === CodeNode$1.getType())) return false;
+				if (selection.getNodes().some((node) => node.getType() === CodeNode.getType())) return false;
 				const text = selection.getTextContent();
 				selection.removeText();
 				selection.insertNodes([$createCodeNode(text), $createCursorNode()]);
@@ -5154,1249 +5198,3174 @@ const CodePlugin = class extends KernelPlugin {
 	}
 };
 //#endregion
-//#region src/plugins/hr/node/HorizontalRuleNode.ts
-var HorizontalRuleNode = class HorizontalRuleNode extends DecoratorNode {
-	static getType() {
-		return "horizontalrule";
-	}
-	static clone(node) {
-		return new HorizontalRuleNode(node.__key);
-	}
-	static importJSON(serializedNode) {
-		return $createHorizontalRuleNode().updateFromJSON(serializedNode);
-	}
-	static importDOM() {
-		return { hr: () => ({
-			conversion: $convertHorizontalRuleElement,
-			priority: 0
-		}) };
-	}
-	exportDOM() {
-		return { element: document.createElement("hr") };
-	}
-	createDOM(config) {
-		const element = document.createElement("div");
-		addClassNamesToElement(element, config.theme.hr);
-		return element;
-	}
-	getTextContent() {
-		return "\n";
-	}
-	isInline() {
-		return false;
-	}
-	updateDOM() {
-		return false;
-	}
-	decorate(editor) {
-		const decorator = getKernelFromEditor(editor)?.getDecorator("horizontalrule");
-		if (!decorator) return null;
-		if (typeof decorator === "function") return decorator(this, editor);
-		return {
-			queryDOM: decorator.queryDOM,
-			render: decorator.render(this, editor)
-		};
-	}
-};
-function $createHorizontalRuleNode() {
-	return $applyNodeReplacement(new HorizontalRuleNode());
-}
-function $convertHorizontalRuleElement() {
-	return { node: $createHorizontalRuleNode() };
-}
-function $isHorizontalRuleNode(node) {
-	return node.getType() === HorizontalRuleNode.getType();
-}
+//#region src/plugins/codeblock/command/symbols.ts
+const UPDATE_CODEBLOCK_LANG = createCommand("UPDATE_CODEBLOCK_LANG");
 //#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, () => {
+//#region src/plugins/codemirror-block/command/index.ts
+const INSERT_CODEMIRROR_COMMAND = createCommand("INSERT_CODEMIRROR_COMMAND");
+const SELECT_BEFORE_CODEMIRROR_COMMAND = createCommand("SELECT_BEFORE_CODEMIRROR_COMMAND");
+const SELECT_AFTER_CODEMIRROR_COMMAND = createCommand("SELECT_AFTER_CODEMIRROR_COMMAND");
+function registerCodeMirrorCommand(editor) {
+	return mergeRegister(editor.registerCommand(INSERT_CODEMIRROR_COMMAND, () => {
 		editor.update(() => {
-			$insertNodes([$createHorizontalRuleNode()]);
+			const codeMirrorNode = $createCodeMirrorNode("", "");
+			$insertNodes([codeMirrorNode]);
+			const selection = $createNodeSelection();
+			selection.add(codeMirrorNode.getKey());
+			$setSelection(selection);
 		});
 		return true;
-	}, COMMAND_PRIORITY_EDITOR);
-}
-//#endregion
-//#region src/plugins/hr/plugin/index.ts
-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", {});
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(UPDATE_CODEBLOCK_LANG, (payload) => {
+		const codeMirrorNode = editor.getEditorState().read(() => {
+			const selection = $getSelection();
+			if ($isRangeSelection(selection)) if (selection.isCollapsed()) return $findMatchingParent(selection.anchor.getNode(), $isCodeMirrorNode);
+			else {
+				const anchor = $findMatchingParent(selection.anchor.getNode(), $isCodeMirrorNode);
+				const focus = $findMatchingParent(selection.focus.getNode(), $isCodeMirrorNode);
+				if (anchor && focus && anchor === focus) return anchor;
+				return null;
+			}
 			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", {});
+		if (!codeMirrorNode) return false;
+		queueMicrotask(() => {
+			editor.update(() => {
+				if ($isCodeMirrorNode(codeMirrorNode)) codeMirrorNode.setLang(payload.lang);
+			});
 		});
-	}
-};
-//#endregion
-//#region src/plugins/link/node/LinkNode.ts
-const logger = createDebugLogger("plugin", "link");
-const SUPPORTED_URL_PROTOCOLS$1 = new Set([
-	"http:",
-	"https:",
-	"mailto:",
-	"sms:",
-	"tel:"
-]);
-const HOVER_LINK_COMMAND = createCommand("HOVER_LINK_COMMAND");
-const HOVER_OUT_LINK_COMMAND = createCommand("HOVER_OUT_LINK_COMMAND");
-/** @noInheritDoc */
-var LinkNode = class LinkNode extends ElementNode {
-	static getType() {
-		return "link";
-	}
-	static clone(node) {
-		return new LinkNode(node.__url, {
-			rel: node.__rel,
-			target: node.__target,
-			title: node.__title
-		}, node.__key);
-	}
-	constructor(url = "", attributes = {}, key) {
-		super(key);
-		const { target = null, rel = null, title = null } = attributes;
-		this.__url = url;
-		this.__target = target;
-		this.__rel = rel;
-		this.__title = title;
-	}
-	createDOM(config, editor) {
-		logger.debug("🔍 config", config);
-		const element = document.createElement("a");
-		this.updateLinkDOM(null, element, config);
-		addClassNamesToElement(element, config.theme.link);
-		element.addEventListener("mouseenter", (event) => {
-			if (event.target instanceof HTMLElement) {
-				event.target.classList.add("hover");
-				editor.dispatchCommand(HOVER_LINK_COMMAND, {
-					event,
-					linkNode: this
-				});
-			}
+		return true;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(SELECT_BEFORE_CODEMIRROR_COMMAND, (payload) => {
+		editor.update(() => {
+			const node = $getNodeByKey(payload.key);
+			if (!node) return;
+			const prevNode = node.getPreviousSibling();
+			const sel = prevNode?.selectEnd();
+			console.info("SELECT_BEFORE_CODEMIRROR_COMMAND", prevNode, sel);
+			if (sel) $setSelection(sel);
+			editor.focus();
 		});
-		element.addEventListener("mouseleave", (event) => {
-			if (event.target instanceof HTMLElement) {
-				event.target.classList.remove("hover");
-				editor.dispatchCommand(HOVER_OUT_LINK_COMMAND, { event });
+		return false;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(SELECT_AFTER_CODEMIRROR_COMMAND, (payload) => {
+		editor.update(() => {
+			const node = $getNodeByKey(payload.key);
+			if (!node) return;
+			const selection = node.getNextSibling()?.selectStart();
+			if (selection) $setSelection(selection);
+			else {
+				const paragraph = $createParagraphNode();
+				node.insertAfter(paragraph);
+				const paragraphSelection = paragraph.selectStart();
+				if (paragraphSelection) $setSelection(paragraphSelection);
 			}
+			editor.focus();
 		});
-		return element;
-	}
-	updateLinkDOM(prevNode, anchor, _config) {
-		if (isHTMLAnchorElement(anchor)) {
-			if (!prevNode || prevNode.__url !== this.__url) anchor.href = this.sanitizeUrl(this.__url);
-			for (const attr of [
-				"target",
-				"rel",
-				"title"
-			]) {
-				const key = `__${attr}`;
-				const value = this[key];
-				if (!prevNode || prevNode[key] !== value) if (value) anchor[attr] = value;
-				else anchor.removeAttribute(attr);
-			}
-		}
-	}
-	updateDOM(prevNode, anchor, config) {
-		this.updateLinkDOM(prevNode, anchor, config);
 		return false;
+	}, COMMAND_PRIORITY_EDITOR));
+}
+//#endregion
+//#region src/codemirror/constants.ts
+const LANGUAGES = [
+	{
+		ext: ["agda"],
+		name: "Agda",
+		syntax: "text/x-agda",
+		value: "agda"
+	},
+	{
+		ext: ["ets", "arkts"],
+		name: "ArkTS",
+		syntax: "text/x-arkts",
+		value: "arkts"
+	},
+	{
+		ext: ["bash"],
+		name: "Bash",
+		syntax: "shell",
+		value: "bash"
+	},
+	{
+		ext: ["vbs"],
+		name: "Basic",
+		syntax: "vbscript",
+		value: "basic"
+	},
+	{
+		ext: [
+			"c",
+			"h",
+			"ino"
+		],
+		name: "C",
+		syntax: "text/x-csrc",
+		value: "c"
+	},
+	{
+		ext: [
+			"cpp",
+			"c++",
+			"cc",
+			"cxx",
+			"hpp",
+			"h++",
+			"hh",
+			"hxx"
+		],
+		name: "C++",
+		syntax: "text/x-c++src",
+		value: "cpp"
+	},
+	{
+		ext: ["cs"],
+		name: "C#",
+		syntax: "text/x-csharp",
+		value: "csharp"
+	},
+	{
+		ext: ["css"],
+		name: "CSS",
+		syntax: "css",
+		value: "css"
+	},
+	{
+		ext: ["dart"],
+		name: "Dart",
+		syntax: "dart",
+		value: "dart"
+	},
+	{
+		ext: ["diff", "patch"],
+		name: "Diff",
+		syntax: "diff",
+		value: "diff"
+	},
+	{
+		name: "Dockerfile",
+		syntax: "dockerfile",
+		value: "dockerfile"
+	},
+	{
+		ext: ["erl"],
+		name: "Erlang",
+		syntax: "erlang",
+		value: "erlang"
+	},
+	{
+		ext: ["glsl"],
+		name: "Glsl",
+		syntax: "x-shader/x-vertex",
+		value: "glsl"
+	},
+	{
+		name: "Git",
+		syntax: "shell",
+		value: "git"
+	},
+	{
+		ext: ["go"],
+		name: "Go",
+		syntax: "go",
+		value: "go"
+	},
+	{
+		name: "GraphQL",
+		syntax: "graphql",
+		value: "graphql"
+	},
+	{
+		ext: ["groovy", "gradle"],
+		name: "Groovy",
+		syntax: "groovy",
+		value: "groovy"
+	},
+	{
+		ext: [
+			"html",
+			"htm",
+			"handlebars",
+			"hbs"
+		],
+		name: "HTML",
+		syntax: "htmlmixed",
+		value: "html"
+	},
+	{
+		name: "HTTP",
+		syntax: "http",
+		value: "http"
+	},
+	{
+		ext: ["java"],
+		name: "Java",
+		syntax: "text/x-java",
+		value: "java"
+	},
+	{
+		ext: ["js"],
+		name: "JavaScript",
+		syntax: "text/javascript",
+		value: "javascript"
+	},
+	{
+		ext: ["json", "map"],
+		name: "JSON",
+		syntax: "application/json",
+		value: "json"
+	},
+	{
+		ext: ["jsx"],
+		name: "JSX",
+		syntax: "jsx",
+		value: "jsx"
+	},
+	{
+		name: "KaTeX",
+		syntax: "simplemode",
+		value: "katex"
+	},
+	{
+		ext: ["kt"],
+		name: "Kotlin",
+		syntax: "text/x-kotlin",
+		value: "kotlin"
+	},
+	{
+		ext: ["less"],
+		name: "Less",
+		syntax: "css",
+		value: "less"
+	},
+	{
+		name: "Makefile",
+		syntax: "cmake",
+		value: "makefile"
+	},
+	{
+		ext: [
+			"markdown",
+			"md",
+			"mkd"
+		],
+		name: "Markdown",
+		syntax: "markdown",
+		value: "markdown"
+	},
+	{
+		name: "MATLAB",
+		syntax: "octave",
+		value: "matlab"
+	},
+	{
+		ext: ["conf"],
+		name: "Nginx",
+		syntax: "nginx",
+		value: "nginx"
+	},
+	{
+		ext: ["m"],
+		name: "Objective-C",
+		syntax: "text/x-objectivec",
+		value: "objectivec"
+	},
+	{
+		ext: ["p", "pas"],
+		name: "Pascal",
+		syntax: "pascal",
+		value: "pascal"
+	},
+	{
+		ext: ["pl", "pm"],
+		name: "Perl",
+		syntax: "perl",
+		value: "perl"
+	},
+	{
+		ext: [
+			"php",
+			"php3",
+			"php4",
+			"php5",
+			"php7",
+			"phtml"
+		],
+		name: "PHP",
+		syntax: "text/x-php",
+		value: "php"
+	},
+	{
+		ext: [
+			"ps1",
+			"psd1",
+			"psm1"
+		],
+		name: "PowerShell",
+		syntax: "powershell",
+		value: "powershell"
+	},
+	{
+		ext: ["proto"],
+		name: "Protobuf",
+		syntax: "protobuf",
+		value: "protobuf"
+	},
+	{
+		ext: [
+			"build",
+			"bzl",
+			"py",
+			"pyw"
+		],
+		name: "Python",
+		syntax: "python",
+		value: "python"
+	},
+	{
+		ext: ["r", "R"],
+		name: "R",
+		syntax: "r",
+		value: "r"
+	},
+	{
+		ext: ["rb"],
+		name: "Ruby",
+		syntax: "ruby",
+		value: "ruby"
+	},
+	{
+		ext: ["rs"],
+		name: "Rust",
+		syntax: "rust",
+		value: "rust"
+	},
+	{
+		ext: ["scala"],
+		name: "Scala",
+		syntax: "text/x-scala",
+		value: "scala"
+	},
+	{
+		ext: ["sh", "ksh"],
+		name: "Shell",
+		syntax: "shell",
+		value: "shell"
+	},
+	{
+		ext: ["sql"],
+		name: "SQL",
+		syntax: "text/x-sql",
+		value: "sql"
+	},
+	{
+		name: "PL/SQL",
+		syntax: "text/x-plsql",
+		value: "plsql"
+	},
+	{
+		ext: ["swift"],
+		name: "Swift",
+		syntax: "swift",
+		value: "swift"
+	},
+	{
+		ext: ["ts"],
+		name: "TypeScript",
+		syntax: "text/typescript",
+		value: "typescript"
+	},
+	{
+		ext: ["vb"],
+		name: "VB.net",
+		syntax: "vb",
+		value: "vbnet"
+	},
+	{
+		ext: ["vtl"],
+		name: "Velocity",
+		syntax: "velocity",
+		value: "velocity"
+	},
+	{
+		ext: [
+			"xml",
+			"xsl",
+			"xsd",
+			"svg"
+		],
+		name: "XML",
+		syntax: "xml",
+		value: "xml"
+	},
+	{
+		ext: ["yaml", "yml"],
+		name: "YAML",
+		syntax: "yaml",
+		value: "yaml"
+	},
+	{
+		name: "sTeX",
+		syntax: "text/x-stex",
+		value: "stex"
+	},
+	{
+		ext: [
+			"text",
+			"ltx",
+			"tex"
+		],
+		name: "LaTeX",
+		syntax: "text/x-latex",
+		value: "latex"
+	},
+	{
+		ext: ["sv", "svh"],
+		name: "SystemVerilog",
+		syntax: "text/x-systemverilog",
+		value: "systemverilog"
+	},
+	{
+		ext: ["sass", "scss"],
+		name: "Sass",
+		syntax: "text/x-sass",
+		value: "sass"
+	},
+	{
+		ext: ["tcl"],
+		name: "Tcl",
+		syntax: "text/x-tcl",
+		value: "tcl"
+	},
+	{
+		ext: ["v"],
+		name: "Verilog",
+		syntax: "text/x-verilog",
+		value: "verilog"
+	},
+	{
+		name: "Vue",
+		syntax: "text/x-vue",
+		value: "vue"
+	},
+	{
+		ext: ["lua"],
+		name: "Lua",
+		syntax: "text/x-lua",
+		value: "lua"
+	},
+	{
+		ext: ["hs"],
+		name: "Haskell",
+		syntax: "haskell",
+		value: "haskell"
+	},
+	{
+		ext: [
+			"properties",
+			"ini",
+			"in"
+		],
+		name: "Properties",
+		syntax: "properties",
+		value: "properties"
+	},
+	{
+		ext: ["toml"],
+		name: "TOML",
+		syntax: "toml",
+		value: "toml"
+	},
+	{
+		ext: ["cyp", "cypher"],
+		name: "Cypher",
+		syntax: "cypher",
+		value: "cypher"
+	},
+	{
+		ext: ["tsx"],
+		name: "TSX",
+		syntax: "jsx",
+		value: "tsx"
+	},
+	{
+		ext: ["fs"],
+		name: "F#",
+		syntax: "mllike",
+		value: "f#"
+	},
+	{
+		ext: [
+			"ml",
+			"mli",
+			"mll",
+			"mly"
+		],
+		name: "OCaml",
+		syntax: "mllike",
+		value: "ocaml"
+	},
+	{
+		ext: [
+			"clj",
+			"cljc",
+			"cljx"
+		],
+		name: "Clojure",
+		syntax: "clojure",
+		value: "clojure"
+	},
+	{
+		name: "ABAP",
+		syntax: "abap",
+		value: "abap"
+	},
+	{
+		ext: ["jl"],
+		name: "Julia",
+		syntax: "julia",
+		value: "julia"
+	},
+	{
+		ext: ["cmake"],
+		name: "CMake",
+		syntax: "cmake",
+		value: "cmake"
+	},
+	{
+		ext: ["scm", "ss"],
+		name: "Scheme",
+		syntax: "scheme",
+		value: "scheme"
+	},
+	{
+		ext: [
+			"cl",
+			"lisp",
+			"el"
+		],
+		name: "Lisp",
+		syntax: "commonlisp",
+		value: "commonlisp"
+	},
+	{
+		ext: [
+			"f90",
+			"f95",
+			"f03"
+		],
+		name: "Fortran",
+		syntax: "fortran",
+		value: "fortran"
+	},
+	{
+		ext: ["sol"],
+		name: "Solidity",
+		syntax: "solidity",
+		value: "solidity"
 	}
-	static importDOM() {
-		return { a: () => ({
-			conversion: $convertAnchorElement,
-			priority: 1
-		}) };
-	}
-	static importJSON(serializedNode) {
-		return $createLinkNode().updateFromJSON(serializedNode);
-	}
-	updateFromJSON(serializedNode) {
-		return super.updateFromJSON(serializedNode).setURL(serializedNode.url).setRel(serializedNode.rel || null).setTarget(serializedNode.target || null).setTitle(serializedNode.title || null);
-	}
-	sanitizeUrl(url) {
-		url = formatUrl(url);
-		try {
-			const parsedUrl = new URL(formatUrl(url));
-			if (!SUPPORTED_URL_PROTOCOLS$1.has(parsedUrl.protocol)) return "about:blank";
-		} catch {
-			return url;
-		}
-		return url;
-	}
-	exportJSON() {
-		return {
-			...super.exportJSON(),
-			rel: this.getRel(),
-			target: this.getTarget(),
-			title: this.getTitle(),
-			url: this.getURL()
-		};
-	}
-	getURL() {
-		return this.getLatest().__url;
-	}
-	setURL(url) {
-		const writable = this.getWritable();
-		writable.__url = url;
-		return writable;
-	}
-	getTarget() {
-		return this.getLatest().__target;
+];
+LANGUAGES.sort((modeA, modeB) => {
+	const nameA = modeA.name.toLowerCase();
+	const nameB = modeB.name.toLowerCase();
+	if (nameA === nameB) return 0;
+	if (nameA < nameB) return -1;
+	return 1;
+});
+LANGUAGES.unshift({
+	name: "Plain Text",
+	syntax: "simplemode",
+	value: "plain"
+});
+//#endregion
+//#region src/plugins/codemirror-block/lib/mode.ts
+function modeMatch(mode = "") {
+	mode = mode.toLocaleLowerCase() || "plain";
+	return LANGUAGES.find((m) => m.value === mode || m.ext?.includes(mode))?.value || "plain";
+}
+//#endregion
+//#region src/plugins/codemirror-block/plugin/index.ts
+const CodemirrorPlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "CodemirrorPlugin";
 	}
-	setTarget(target) {
-		const writable = this.getWritable();
-		writable.__target = target;
-		return writable;
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		kernel.registerNodes([CodeMirrorNode]);
+		kernel.registerThemes({ hr: config?.theme || "" });
+		this.registerDecorator(kernel, "codemirror", (node, editor) => {
+			return config?.decorator ? config.decorator(node, editor) : null;
+		});
 	}
-	getRel() {
-		return this.getLatest().__rel;
+	onInit(editor) {
+		this.register(registerCodeMirrorCommand(editor));
+		this.registerMarkdown();
+		this.registerLiteXml();
 	}
-	setRel(rel) {
-		const writable = this.getWritable();
-		writable.__rel = rel;
-		return writable;
+	registerLiteXml() {
+		const litexmlService = this.kernel.requireService(ILitexmlService);
+		if (!litexmlService) return;
+		litexmlService.registerXMLWriter(CodeMirrorNode.getType(), (node, ctx) => {
+			const codeMirrorNode = node;
+			return ctx.createXmlNode("code", { lang: codeMirrorNode.lang || "plain" }, codeMirrorNode.code);
+		});
+		litexmlService.registerXMLReader("code", (xmlElement, children) => {
+			const text = children.map((v) => v.text || "").join("");
+			const language = xmlElement.getAttribute("lang") || "plain";
+			return INodeHelper.createTypeNode("code", {
+				code: text || xmlElement.textContent || "",
+				language: modeMatch(language),
+				version: 1
+			});
+		});
 	}
-	getTitle() {
-		return this.getLatest().__title;
+	registerMarkdown() {
+		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
+		markdownService?.registerMarkdownShortCut({
+			regExp: /^(```|···)(.+)?$/,
+			replace: (parentNode, _, match) => {
+				const code = $createCodeMirrorNode(modeMatch(match[2]), "");
+				parentNode.replace(code);
+				const sel = $createNodeSelection();
+				sel.add(code.getKey());
+				$setSelection(sel);
+			},
+			trigger: "enter",
+			type: "element"
+		});
+		markdownService?.registerMarkdownWriter(CodeMirrorNode.getType(), (ctx, node) => {
+			if (node instanceof CodeMirrorNode) {
+				ctx.appendLine("```" + node.lang);
+				ctx.appendLine("\n");
+				ctx.appendLine(node.code);
+				ctx.appendLine("\n```\n");
+			}
+		});
+		markdownService?.registerMarkdownReader("code", (node) => {
+			const language = node.lang ? modeMatch(node.lang) : "plain";
+			return INodeHelper.createTypeNode("code", {
+				code: node.value,
+				language,
+				version: 1
+			});
+		});
 	}
-	setTitle(title) {
-		const writable = this.getWritable();
-		writable.__title = title;
-		return writable;
+};
+//#endregion
+//#region src/plugins/upload/service/i-upload-service.ts
+const IUploadService = genServiceId("UploadService");
+//#endregion
+//#region src/plugins/file/node/FileNode.ts
+var FileNode = class FileNode extends DecoratorNode {
+	static getType() {
+		return "file";
 	}
-	insertNewAfter(_, restoreSelection = true) {
-		const linkNode = $createLinkNode(this.__url, {
-			rel: this.__rel,
-			target: this.__target,
-			title: this.__title
-		});
-		this.insertAfter(linkNode, restoreSelection);
-		return linkNode;
+	static clone(node) {
+		return new FileNode(node.__name, node.__fileUrl, node.__size, node.__status, node.__message, node.__key);
 	}
-	canInsertTextBefore() {
-		return false;
+	static importJSON(serializedNode) {
+		return new FileNode(serializedNode.name, serializedNode.fileUrl, serializedNode.size, serializedNode.status, serializedNode.message);
 	}
-	canInsertTextAfter() {
-		return false;
+	static importDOM() {
+		return { span: (node) => {
+			if (node.classList.contains("file")) return {
+				conversion: $convertFileElement,
+				priority: 0
+			};
+			return null;
+		} };
 	}
-	canBeEmpty() {
-		return false;
+	get name() {
+		return this.__name;
 	}
-	isInline() {
-		return true;
+	get fileUrl() {
+		return this.__fileUrl;
 	}
-	extractWithChild(child, selection) {
-		if (!$isRangeSelection(selection)) return false;
-		const anchorNode = selection.anchor.getNode();
-		const focusNode = selection.focus.getNode();
-		return this.isParentOf(anchorNode) && this.isParentOf(focusNode) && selection.getTextContent().length > 0;
+	get size() {
+		return this.__size;
 	}
-	isEmailURI() {
-		return this.__url.startsWith("mailto:");
+	get status() {
+		return this.__status;
 	}
-	isWebSiteURI() {
-		return this.__url.startsWith("https://") || this.__url.startsWith("http://");
+	get message() {
+		return this.__message;
 	}
-};
-function $convertAnchorElement(domNode) {
-	let node = null;
-	if (isHTMLAnchorElement(domNode)) {
-		const content = domNode.textContent;
-		if (content !== null && content !== "" || domNode.children.length > 0) node = $createLinkNode(domNode.getAttribute("href") || "", {
-			rel: domNode.getAttribute("rel"),
-			target: domNode.getAttribute("target"),
-			title: domNode.getAttribute("title")
-		});
-	}
-	return { node };
-}
-/**
-* Takes a URL and creates a LinkNode.
-* @param url - The URL the LinkNode should direct to.
-* @param attributes - Optional HTML a tag attributes \\{ target, rel, title \\}
-* @returns The LinkNode.
-*/
-function $createLinkNode(url = "", attributes) {
-	return $applyNodeReplacement(new LinkNode(url, attributes));
-}
-/**
-* Determines if node is a LinkNode.
-* @param node - The node to be checked.
-* @returns true if node is a LinkNode, false otherwise.
-*/
-function $isLinkNode(node) {
-	return node instanceof LinkNode;
-}
-var AutoLinkNode = class AutoLinkNode extends LinkNode {
-	constructor(url = "", attributes = {}, key) {
-		super(url, attributes, key);
-		this.__isUnlinked = attributes.isUnlinked !== void 0 && attributes.isUnlinked !== null ? attributes.isUnlinked : false;
-	}
-	static getType() {
-		return "autolink";
-	}
-	static clone(node) {
-		return new AutoLinkNode(node.__url, {
-			isUnlinked: node.__isUnlinked,
-			rel: node.__rel,
-			target: node.__target,
-			title: node.__title
-		}, node.__key);
+	constructor(name, fileUrl, size, status, message, key) {
+		super(key);
+		this.__name = name;
+		this.__fileUrl = fileUrl;
+		this.__size = size;
+		this.__status = status || "pending";
+		this.__message = message;
 	}
-	getIsUnlinked() {
-		return this.__isUnlinked;
+	setUploaded(url) {
+		const writable = this.getWritable();
+		writable.__fileUrl = url;
+		writable.__status = "uploaded";
+		writable.__message = void 0;
 	}
-	setIsUnlinked(value) {
-		const self = this.getWritable();
-		self.__isUnlinked = value;
-		return self;
+	setError(message) {
+		const writable = this.getWritable();
+		writable.__status = "error";
+		writable.__message = message;
 	}
-	createDOM(config, editor) {
-		logger.debug("🔍 config", config);
-		if (this.__isUnlinked) return document.createElement("span");
-		else return super.createDOM(config, editor);
+	exportDOM() {
+		return { element: document.createElement("span") };
 	}
-	updateDOM(prevNode, anchor, config) {
-		return super.updateDOM(prevNode, anchor, config) || prevNode.__isUnlinked !== this.__isUnlinked;
+	createDOM(config) {
+		const element = document.createElement("span");
+		addClassNamesToElement(element, config.theme.file);
+		return element;
 	}
-	static importJSON(serializedNode) {
-		return $createAutoLinkNode().updateFromJSON(serializedNode);
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			fileUrl: this.fileUrl,
+			message: this.message,
+			name: this.name,
+			size: this.size,
+			status: this.status
+		};
 	}
 	updateFromJSON(serializedNode) {
-		return super.updateFromJSON(serializedNode).setIsUnlinked(serializedNode.isUnlinked || false);
+		return super.updateFromJSON(serializedNode);
 	}
-	static importDOM() {
-		return null;
+	getTextContent() {
+		return "\n";
 	}
-	exportJSON() {
+	updateDOM() {
+		return false;
+	}
+	decorate(editor) {
+		const decorator = getKernelFromEditor(editor)?.getDecorator("file");
+		if (!decorator) return null;
+		if (typeof decorator === "function") return decorator(this, editor);
 		return {
-			...super.exportJSON(),
-			isUnlinked: this.__isUnlinked
+			queryDOM: decorator.queryDOM,
+			render: decorator.render(this, editor)
 		};
 	}
-	insertNewAfter(selection, restoreSelection = true) {
-		const element = this.getParentOrThrow().insertNewAfter(selection, restoreSelection);
-		if ($isElementNode(element)) {
-			const linkNode = $createAutoLinkNode(this.__url, {
-				isUnlinked: this.__isUnlinked,
-				rel: this.__rel,
-				target: this.__target,
-				title: this.__title
-			});
-			element.append(linkNode);
-			return linkNode;
-		}
-		return null;
-	}
 };
-/**
-* Takes a URL and creates an AutoLinkNode. AutoLinkNodes are generally automatically generated
-* during typing, which is especially useful when a button to generate a LinkNode is not practical.
-* @param url - The URL the LinkNode should direct to.
-* @param attributes - Optional HTML a tag attributes. \\{ target, rel, title \\}
-* @returns The LinkNode.
-*/
-function $createAutoLinkNode(url = "", attributes) {
-	return $applyNodeReplacement(new AutoLinkNode(url, attributes));
+function $createFileNode(name = "unknown", fileUrl, size, status, message) {
+	return $applyNodeReplacement(new FileNode(name, fileUrl, size, status, message));
 }
-/**
-* Determines if node is an AutoLinkNode.
-* @param node - The node to be checked.
-* @returns true if node is an AutoLinkNode, false otherwise.
-*/
-function $isAutoLinkNode(node) {
-	return node instanceof AutoLinkNode;
+function $convertFileElement() {
+	return { node: $createFileNode() };
 }
-const TOGGLE_LINK_COMMAND = createCommand("TOGGLE_LINK_COMMAND");
-function $getPointNode(point, offset) {
-	if (point.type === "element") {
-		const node = point.getNode();
-		assert($isElementNode(node), "$getPointNode: element point is not an ElementNode");
-		return node.getChildren()[point.offset + offset] || null;
-	}
-	return null;
+function $isFileNode(node) {
+	return node.getType() === FileNode.getType();
 }
-/**
-* Preserve the logical start/end of a RangeSelection in situations where
-* the point is an element that may be reparented in the callback.
-*
-* @param $fn The function to run
-* @returns The result of the callback
-*/
-function $withSelectedNodes($fn) {
-	const initialSelection = $getSelection();
-	if (!$isRangeSelection(initialSelection)) return $fn();
-	const normalized = $normalizeSelection__EXPERIMENTAL(initialSelection);
-	const isBackwards = normalized.isBackward();
-	const anchorNode = $getPointNode(normalized.anchor, isBackwards ? -1 : 0);
-	const focusNode = $getPointNode(normalized.focus, isBackwards ? 0 : -1);
-	const rval = $fn();
-	if (anchorNode || focusNode) {
-		const updatedSelection = $getSelection();
-		if ($isRangeSelection(updatedSelection)) {
-			const finalSelection = updatedSelection.clone();
-			if (anchorNode) {
-				const anchorParent = anchorNode.getParent();
-				if (anchorParent) finalSelection.anchor.set(anchorParent.getKey(), anchorNode.getIndexWithinParent() + (isBackwards ? 1 : 0), "element");
-			}
-			if (focusNode) {
-				const focusParent = focusNode.getParent();
-				if (focusParent) finalSelection.focus.set(focusParent.getKey(), focusNode.getIndexWithinParent() + (isBackwards ? 0 : 1), "element");
-			}
-			$setSelection($normalizeSelection__EXPERIMENTAL(finalSelection));
-		}
-	}
-	return rval;
+//#endregion
+//#region src/plugins/file/command/index.ts
+const logger$2 = createDebugLogger("plugin", "file");
+const INSERT_FILE_COMMAND = createCommand("INSERT_FILE_COMMAND");
+function registerFileCommand(editor, handleUpload) {
+	return editor.registerCommand(INSERT_FILE_COMMAND, (payload) => {
+		const { file } = payload;
+		editor.update(() => {
+			const fileNode = $createFileNode(file.name);
+			$insertNodes([fileNode]);
+			if ($isRootOrShadowRoot(fileNode.getParentOrThrow())) $wrapNodeInElement(fileNode, $createParagraphNode).selectEnd();
+			handleUpload(file).then((url) => {
+				editor.update(() => {
+					fileNode.setUploaded(url.url);
+				});
+			}).catch((error) => {
+				logger$2.error("❌ File upload failed:", error);
+				editor.update(() => {
+					fileNode.setError("File upload failed : " + error.message);
+				});
+			});
+		});
+		return false;
+	}, COMMAND_PRIORITY_HIGH);
 }
-/**
-* Generates or updates a LinkNode. It can also delete a LinkNode if the URL is null,
-* but saves any children and brings them up to the parent node.
-* @param url - The URL the link directs to.
-* @param attributes - Optional HTML a tag attributes. \\{ target, rel, title \\}
-*/
-function $toggleLink(url, attributes = {}) {
-	const { target, title } = attributes;
-	const rel = attributes.rel === void 0 ? "noreferrer" : attributes.rel;
-	const selection = $getSelection();
-	if (selection === null || !$isRangeSelection(selection) && !$isNodeSelection(selection)) return;
-	if ($isNodeSelection(selection)) {
-		const nodes = selection.getNodes();
-		if (nodes.length === 0) return;
-		nodes.forEach((node) => {
-			if (url === null) {
-				const linkParent = $findMatchingParent(node, (parent) => !$isAutoLinkNode(parent) && $isLinkNode(parent));
-				if (linkParent) {
-					linkParent.insertBefore(node);
-					if (linkParent.getChildren().length === 0) linkParent.remove();
-				}
-			} else {
-				const existingLink = $findMatchingParent(node, (parent) => !$isAutoLinkNode(parent) && $isLinkNode(parent));
-				if (existingLink) {
-					existingLink.setURL(url);
-					if (target !== void 0) existingLink.setTarget(target);
-					if (rel !== void 0) existingLink.setRel(rel);
-				} else {
-					const linkNode = $createLinkNode(url, {
-						rel,
-						target
+//#endregion
+//#region src/plugins/file/utils/index.ts
+function registerFileNodeSelectionObserver(editor) {
+	const selectFileKeys = [];
+	return editor.registerUpdateListener(({ editorState }) => {
+		const selection = editorState.read(() => $getSelection());
+		const newSelectFileKeys = [];
+		if ($isNodeSelection(selection)) editorState.read(() => selection.getNodes()).forEach((node) => {
+			if (node.getType() === "file") newSelectFileKeys.push(node.getKey());
+		});
+		else if ($isRangeSelection(selection) && !selection.isCollapsed()) editorState.read(() => {
+			selection.getNodes().forEach((node) => {
+				if (node.getType() === "file") newSelectFileKeys.push(node.getKey());
+			});
+		});
+		const removeKeys = selectFileKeys.filter((key) => !newSelectFileKeys.includes(key));
+		const addKeys = newSelectFileKeys.filter((key) => !selectFileKeys.includes(key));
+		selectFileKeys.length = 0;
+		selectFileKeys.push(...newSelectFileKeys);
+		removeKeys.forEach((key) => {
+			editor.getElementByKey(key)?.classList.remove("selected");
+		});
+		addKeys.forEach((key) => {
+			editor.getElementByKey(key)?.classList.add("selected");
+		});
+	});
+}
+//#endregion
+//#region src/plugins/file/plugin/index.ts
+const FilePlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "FilePlugin";
+	}
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		this.config = config;
+		this.logger = createDebugLogger("plugin", "file");
+		kernel.registerNodes([FileNode]);
+		if (config?.theme) kernel.registerThemes(config?.theme);
+		this.registerDecorator(kernel, FileNode.getType(), (node, editor) => {
+			return config?.decorator ? config.decorator(node, editor) : null;
+		});
+	}
+	onInit(editor) {
+		const handleUpload = this.config?.handleUpload;
+		if (handleUpload) {
+			this.kernel.requireService(IUploadService)?.registerUpload(async (file, from, range) => {
+				editor.update(() => {
+					if (range) {
+						const rangeSelection = $createRangeSelection();
+						if (range !== null && range !== void 0) rangeSelection.applyDOMRange(range);
+						$setSelection(rangeSelection);
+					}
+					const fileNode = $createFileNode(file.name);
+					$insertNodes([fileNode]);
+					if ($isRootOrShadowRoot(fileNode.getParentOrThrow())) $wrapNodeInElement(fileNode, $createParagraphNode).selectEnd();
+					handleUpload(file).then((url) => {
+						editor.update(() => {
+							fileNode.setUploaded(url.url);
+						});
+					}).catch((error) => {
+						this.logger.error("File upload failed:", error);
+						editor.update(() => {
+							fileNode.setError("File upload failed : " + error.message);
+						});
 					});
-					node.insertBefore(linkNode);
-					linkNode.append(node);
-				}
-			}
+				});
+				return null;
+			});
+			this.register(registerFileCommand(editor, handleUpload));
+		}
+		if (this.config?.decorator) this.register(registerFileNodeSelectionObserver(editor));
+		this.registerLiteXml();
+		this.registerMarkdownWriter();
+	}
+	registerLiteXml() {
+		const litexmlService = this.kernel.requireService(ILitexmlService);
+		if (!litexmlService) return;
+		litexmlService.registerXMLWriter(FileNode.getType(), (node, ctx) => {
+			if ($isFileNode(node)) return ctx.createXmlNode("file", {
+				fileUrl: node.fileUrl || "",
+				message: node.message || "",
+				name: node.name,
+				size: node.size?.toString() || "0",
+				status: node.status
+			});
+			return false;
+		});
+		litexmlService.registerXMLReader("file", (xmlElement) => {
+			const name = xmlElement.getAttribute("name") || "unknown";
+			const fileUrl = xmlElement.getAttribute("fileUrl") || "";
+			const status = xmlElement.getAttribute("status");
+			return INodeHelper.createTypeNode(FileNode.getType(), {
+				fileUrl,
+				message: xmlElement.getAttribute("message") || "",
+				name,
+				size: parseInt(xmlElement.getAttribute("size") || "0", 10),
+				status
+			});
 		});
-		return;
 	}
-	const nodes = selection.extract();
-	if (url === null) {
-		nodes.forEach((node) => {
-			const parentLink = $findMatchingParent(node, (parent) => !$isAutoLinkNode(parent) && $isLinkNode(parent));
-			if (parentLink) {
-				const children = parentLink.getChildren();
-				for (const child of children) parentLink.insertBefore(child);
-				parentLink.remove();
+	registerMarkdownWriter() {
+		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
+		if (!markdownService) return;
+		markdownService.registerMarkdownWriter(FileNode.getType(), (ctx, node) => {
+			if ($isFileNode(node)) {
+				if (this.config?.markdownWriter) {
+					ctx.appendLine(this.config.markdownWriter(node));
+					return;
+				}
+				if (node.status === "pending") ctx.appendLine(`Uploading ${node.name}...`);
+				else if (node.status === "error") ctx.appendLine(`Failed to upload ${node.name}: ${node.message}`);
+				else ctx.appendLine(`[${node.name}](${node.fileUrl})`);
 			}
 		});
-		return;
 	}
-	const updatedNodes = /* @__PURE__ */ new Set();
-	const updateLinkNode = (linkNode) => {
-		if (updatedNodes.has(linkNode.getKey())) return;
-		updatedNodes.add(linkNode.getKey());
-		linkNode.setURL(url);
-		if (target !== void 0) linkNode.setTarget(target);
-		if (rel !== void 0) linkNode.setRel(rel);
-		if (title !== void 0) linkNode.setTitle(title);
-	};
-	if (nodes.length === 1) {
-		const firstNode = nodes[0];
-		const linkNode = $getAncestor(firstNode, $isLinkNode);
-		if (linkNode !== null) return updateLinkNode(linkNode);
+};
+//#endregion
+//#region src/plugins/hr/node/HorizontalRuleNode.ts
+var HorizontalRuleNode = class HorizontalRuleNode extends DecoratorNode {
+	static getType() {
+		return "horizontalrule";
 	}
-	$withSelectedNodes(() => {
-		let linkNode = null;
-		for (const node of nodes) {
-			if (!node.isAttached()) continue;
-			const parentLinkNode = $getAncestor(node, $isLinkNode);
-			if (parentLinkNode) {
-				updateLinkNode(parentLinkNode);
-				continue;
-			}
-			if ($isElementNode(node)) {
-				if (!node.isInline()) continue;
-				if ($isLinkNode(node)) {
-					if (!$isAutoLinkNode(node) && (linkNode === null || !linkNode.getParentOrThrow().isParentOf(node))) {
-						updateLinkNode(node);
-						linkNode = node;
-						continue;
-					}
-					for (const child of node.getChildren()) node.insertBefore(child);
-					node.remove();
-					continue;
-				}
-			}
-			const prevLinkNode = node.getPreviousSibling();
-			if ($isLinkNode(prevLinkNode) && prevLinkNode.is(linkNode)) {
-				prevLinkNode.append(node);
-				continue;
-			}
-			linkNode = $createLinkNode(url, {
-				rel,
-				target,
-				title
-			});
-			node.insertAfter(linkNode);
-			linkNode.append(node);
-		}
-	});
+	static clone(node) {
+		return new HorizontalRuleNode(node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createHorizontalRuleNode().updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { hr: () => ({
+			conversion: $convertHorizontalRuleElement,
+			priority: 0
+		}) };
+	}
+	exportDOM() {
+		return { element: document.createElement("hr") };
+	}
+	createDOM(config) {
+		const element = document.createElement("div");
+		addClassNamesToElement(element, config.theme.hr);
+		return element;
+	}
+	getTextContent() {
+		return "\n";
+	}
+	isInline() {
+		return false;
+	}
+	updateDOM() {
+		return false;
+	}
+	decorate(editor) {
+		const decorator = getKernelFromEditor(editor)?.getDecorator("horizontalrule");
+		if (!decorator) return null;
+		if (typeof decorator === "function") return decorator(this, editor);
+		return {
+			queryDOM: decorator.queryDOM,
+			render: decorator.render(this, editor)
+		};
+	}
+};
+function $createHorizontalRuleNode() {
+	return $applyNodeReplacement(new HorizontalRuleNode());
 }
-function $getAncestor(node, predicate) {
-	let parent = node;
-	while (parent !== null && parent.getParent() !== null && !predicate(parent)) parent = parent.getParentOrThrow();
-	return predicate(parent) ? parent : null;
+function $convertHorizontalRuleElement() {
+	return { node: $createHorizontalRuleNode() };
 }
-const PHONE_NUMBER_REGEX = /^\+?[\d\s()-]{5,}$/;
-/**
-* Formats a URL string by adding appropriate protocol if missing
-*
-* @param url - URL to format
-* @returns Formatted URL with appropriate protocol
-*/
-function formatUrl(url) {
-	if (/^[a-z][\d+.a-z-]*:/i.test(url)) return url;
-	else if (/^[#./]/.test(url)) return url;
-	else if (url.includes("@")) return `mailto:${url}`;
-	else if (PHONE_NUMBER_REGEX.test(url)) return `tel:${url}`;
-	return url;
+function $isHorizontalRuleNode(node) {
+	return node.getType() === HorizontalRuleNode.getType();
 }
 //#endregion
-//#region src/plugins/link/command/index.ts
-const INSERT_LINK_COMMAND = createCommand("INSERT_LINK_COMMAND");
-const UPDATE_LINK_TEXT_COMMAND = createCommand("UPDATE_LINK_TEXT_COMMAND");
-function registerLinkCommand(editor) {
-	return mergeRegister(editor.registerCommand(INSERT_LINK_COMMAND, (payload) => {
-		const { url, title = url } = payload;
-		editor.update(() => {
-			const linkNode = $createLinkNode(url, { title });
-			const textNode = $createTextNode(title);
-			linkNode.append(textNode);
-			$insertNodes([linkNode]);
-		});
-		return false;
-	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(UPDATE_LINK_TEXT_COMMAND, (payload) => {
-		const { key, text } = payload;
+//#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(() => {
-			const linkNode = $getNodeByKey(key);
-			if (linkNode) {
-				const newLinkNode = $createLinkNode(linkNode.getURL(), { title: text });
-				const textNode = $createTextNode(text);
-				newLinkNode.append(textNode);
-				linkNode?.replace(newLinkNode);
-				newLinkNode.select(1);
-			}
+			$insertNodes([$createHorizontalRuleNode()]);
 		});
-		return false;
-	}, COMMAND_PRIORITY_EDITOR));
+		return true;
+	}, COMMAND_PRIORITY_EDITOR);
 }
 //#endregion
-//#region src/plugins/link/service/i-link-service.ts
-const ILinkService = genServiceId("LinkService");
-var LinkService = class extends EventEmitter {
-	constructor(..._args) {
-		super(..._args);
-		this._enableLinkToolbar = true;
+//#region src/plugins/hr/plugin/index.ts
+const HRPlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "HRPlugin";
 	}
-	get enableLinkToolbar() {
-		return this._enableLinkToolbar;
+	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;
+		});
 	}
-	setLinkToolbar(enable) {
-		this._enableLinkToolbar = enable;
-		this.emit("linkToolbarChange", enable);
+	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/link/utils/index.ts
-const SUPPORTED_URL_PROTOCOLS = new Set([
-	"http:",
-	"https:",
-	"mailto:",
-	"sms:",
-	"tel:"
-]);
-function sanitizeUrl(url) {
-	try {
-		const parsedUrl = new URL(url);
-		if (!SUPPORTED_URL_PROTOCOLS.has(parsedUrl.protocol)) return "about:blank";
-	} catch {
-		return url;
+//#region src/plugins/image/node/basie-image-node.ts
+var BaseImageNode = class BaseImageNode extends DecoratorNode {
+	static clone(node) {
+		return new BaseImageNode(node.__src, node.__altText, node.__maxWidth, node.__width, node.__height, node.__key);
 	}
-	return url;
-}
-const urlRegExp = /* @__PURE__ */ new RegExp(/((([A-Za-z]{3,9}:(?:\/\/)?)(?:[\w$&+,:;=-]+@)?[\d.A-Za-z-]+|(?:www.|[\w$&+,:;=-]+@)[\d.A-Za-z-]+)((?:\/[%+./~\w-_]*)?\??[\w%&+.;=@-]*#?\w*)?)/);
-function extractUrlFromText(text) {
-	const match = urlRegExp.exec(text);
-	if (!match) return null;
-	const raw = match[0];
-	const start = match.index ?? text.indexOf(raw);
-	const trimmed = raw.replace(/[)\],.;:]+$/u, "");
-	return {
-		index: start,
-		length: trimmed.length,
-		url: trimmed
-	};
-}
-function getSelectedNode(selection) {
-	const anchor = selection.anchor;
-	const focus = selection.focus;
-	const anchorNode = selection.anchor.getNode();
-	const focusNode = selection.focus.getNode();
-	if (anchorNode === focusNode) return anchorNode;
-	if (selection.isBackward()) return $isAtNodeEnd(focus) ? anchorNode : focusNode;
-	else return $isAtNodeEnd(anchor) ? anchorNode : focusNode;
-}
-//#endregion
-//#region src/plugins/link/plugin/registry.ts
-function registerLinkCommands(editor, kernel, options) {
-	const { validateUrl, attributes, enableHotkey = true } = options || {};
-	const state = { isLink: false };
-	const registrations = [editor.registerUpdateListener(() => {
-		const selection = editor.getEditorState().read(() => $getSelection());
-		if (!selection) return;
-		if ($isRangeSelection(selection)) editor.getEditorState().read(() => {
-			const node = getSelectedNode(selection);
-			state.isLink = $isLinkNode(node.getParent()) || $isLinkNode(node);
-		});
-		else state.isLink = false;
-	}), editor.registerCommand(TOGGLE_LINK_COMMAND, (payload) => {
-		if (payload === null) {
-			$toggleLink(payload);
-			return true;
-		} else if (typeof payload === "string") {
-			if (validateUrl === void 0 || validateUrl(payload)) {
-				$toggleLink(payload, attributes);
-				return true;
-			}
-			return false;
-		} else {
-			const { url, target, rel, title } = payload;
-			$toggleLink(url, {
-				...attributes,
-				rel,
-				target,
-				title
-			});
-			return true;
-		}
-	}, COMMAND_PRIORITY_LOW)];
-	registrations.push(kernel.registerHotkey(HotkeyEnum.Link, () => {
-		if (state.isLink) {
-			editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
-			return;
-		}
-		let nextUrl = sanitizeUrl("https://");
-		let expandTo = null;
-		editor.getEditorState().read(() => {
-			const selection = $getSelection();
-			if ($isRangeSelection(selection)) if (!selection.isCollapsed()) {
-				const maybeUrl = formatUrl(selection.getTextContent().trim());
-				if (validateUrl?.(maybeUrl)) nextUrl = maybeUrl;
-			} else {
-				const found = extractUrlFromText(selection.anchor.getNode().getTextContent());
-				if (found && validateUrl?.(formatUrl(found.url))) {
-					nextUrl = formatUrl(found.url);
-					expandTo = {
-						index: found.index,
-						length: found.length
-					};
-				}
-			}
+	static importJSON(serializedNode) {
+		const { altText, height, width, maxWidth, src } = serializedNode;
+		return new BaseImageNode(src, altText, maxWidth, width, height);
+	}
+	static getType() {
+		return "image";
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode);
+	}
+	exportDOM() {
+		const element = document.createElement("img");
+		element.setAttribute("src", this.__src);
+		element.setAttribute("alt", this.__altText);
+		element.setAttribute("width", this.__width.toString());
+		element.setAttribute("height", this.__height.toString());
+		return { element };
+	}
+	constructor(src, altText, maxWidth, width, height, key) {
+		super(key);
+		this.__src = src;
+		this.__altText = altText;
+		this.__maxWidth = maxWidth;
+		this.__width = width || "inherit";
+		this.__height = height || "inherit";
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			altText: this.getAltText(),
+			height: this.__height === "inherit" ? 0 : this.__height,
+			maxWidth: this.__maxWidth,
+			src: this.getSrc(),
+			width: this.__width === "inherit" ? 0 : this.__width
+		};
+	}
+	setWidthAndHeight(width, height) {
+		const writable = this.getWritable();
+		writable.__width = width;
+		writable.__height = height;
+	}
+	isInline() {
+		return true;
+	}
+	createDOM(config) {
+		const span = document.createElement("span");
+		const className = config.theme.image;
+		if (className !== void 0) span.className = className;
+		return span;
+	}
+	updateDOM() {
+		return false;
+	}
+	getSrc() {
+		return this.__src;
+	}
+	getAltText() {
+		return this.__altText;
+	}
+};
+//#endregion
+//#region src/plugins/image/node/block-image-node.tsx
+var BlockImageNode = class BlockImageNode extends BaseImageNode {
+	static {
+		this._decorate = () => null;
+	}
+	static setDecorate(decorate) {
+		BlockImageNode._decorate = decorate;
+	}
+	static getType() {
+		return "block-image";
+	}
+	get isLoading() {
+		return this.__loading;
+	}
+	get status() {
+		return this.__status;
+	}
+	get message() {
+		return this.__message;
+	}
+	get src() {
+		return this.__src;
+	}
+	get altText() {
+		return this.__altText;
+	}
+	get maxWidth() {
+		return this.__maxWidth;
+	}
+	get width() {
+		return this.__width;
+	}
+	get height() {
+		return this.__height;
+	}
+	constructor(opt) {
+		super(opt.src, opt.altText, opt.maxWidth, opt.width, opt.height, opt.key);
+		this.__loading = true;
+		this.__status = "uploaded";
+		this.__message = null;
+		this.__extra = null;
+		this.__status = opt.status ?? "uploaded";
+	}
+	isInline() {
+		return false;
+	}
+	setMaxWidth(maxWidth) {
+		const writable = this.getWritable();
+		writable.__maxWidth = maxWidth;
+	}
+	setWidth(width) {
+		const writable = this.getWritable();
+		writable.__width = width;
+	}
+	setStatus(status) {
+		const writable = this.getWritable();
+		writable.__status = status;
+	}
+	setUploaded(url) {
+		const writable = this.getWritable();
+		writable.__loading = false;
+		writable.__src = url;
+		writable.__status = "uploaded";
+	}
+	setError(message) {
+		const writable = this.getWritable();
+		writable.__loading = false;
+		writable.__status = "error";
+		writable.__message = message;
+	}
+	static clone(node) {
+		return new BlockImageNode({
+			altText: node.__altText,
+			height: node.__height,
+			key: node.__key,
+			maxWidth: node.__maxWidth,
+			src: node.__src,
+			status: node.__status,
+			width: node.__width
+		});
+	}
+	static importJSON(serializedNode) {
+		const { altText, height, width, maxWidth, src, status } = serializedNode;
+		return $createBlockImageNode({
+			altText,
+			height,
+			maxWidth,
+			src,
+			status,
+			width
+		}).updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { img: () => ({
+			conversion: $convertImageElement$1,
+			priority: 0
+		}) };
+	}
+	decorate() {
+		return BlockImageNode._decorate(this);
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			status: this.__status
+		};
+	}
+	createDOM(config) {
+		const span = document.createElement("div");
+		const className = config.theme.blockImage;
+		if (className !== void 0) span.className = className;
+		return span;
+	}
+};
+function $createBlockImageNode({ altText, height, maxWidth = 4200, src, width, key, status }) {
+	return $applyNodeReplacement(new BlockImageNode({
+		altText,
+		height,
+		key,
+		maxWidth,
+		src,
+		status,
+		width
+	}));
+}
+function $convertImageElement$1(domNode) {
+	const img = domNode;
+	if (img.src.startsWith("file:///")) return null;
+	const { alt: altText, src, width, height } = img;
+	return { node: $createBlockImageNode({
+		altText,
+		height,
+		src,
+		width
+	}) };
+}
+function $isBlockImageNode(node) {
+	return node.getType() === BlockImageNode.getType();
+}
+//#endregion
+//#region src/plugins/image/node/image-node.tsx
+var ImageNode = class ImageNode extends BaseImageNode {
+	static {
+		this._decorate = () => null;
+	}
+	static setDecorate(decorate) {
+		ImageNode._decorate = decorate;
+	}
+	static getType() {
+		return "image";
+	}
+	constructor(opt) {
+		super(opt.src, opt.altText, opt.maxWidth, opt.width, opt.height, opt.key);
+		this.__loading = true;
+		this.__status = "uploaded";
+		this.__message = null;
+		this.__extra = null;
+		this.__status = opt.status ?? "uploaded";
+	}
+	get isLoading() {
+		return this.__loading;
+	}
+	get status() {
+		return this.__status;
+	}
+	get message() {
+		return this.__message;
+	}
+	get src() {
+		return this.__src;
+	}
+	get altText() {
+		return this.__altText;
+	}
+	get maxWidth() {
+		return this.__maxWidth;
+	}
+	get width() {
+		return this.__width;
+	}
+	get height() {
+		return this.__height;
+	}
+	setMaxWidth(maxWidth) {
+		const writable = this.getWritable();
+		writable.__maxWidth = maxWidth;
+	}
+	setStatus(status) {
+		const writable = this.getWritable();
+		writable.__status = status;
+	}
+	setWidth(width) {
+		const writable = this.getWritable();
+		writable.__width = width;
+	}
+	setUploaded(url) {
+		const writable = this.getWritable();
+		writable.__loading = false;
+		writable.__src = url;
+		writable.__status = "uploaded";
+	}
+	setError(message) {
+		const writable = this.getWritable();
+		writable.__loading = false;
+		writable.__status = "error";
+		writable.__message = message;
+	}
+	static clone(node) {
+		return new ImageNode({
+			altText: node.__altText,
+			height: node.__height,
+			key: node.__key,
+			maxWidth: node.__maxWidth,
+			src: node.__src,
+			status: node.__status,
+			width: node.__width
 		});
+	}
+	static importJSON(serializedNode) {
+		const { altText, height, width, maxWidth, src, status } = serializedNode;
+		return $createImageNode({
+			altText,
+			height,
+			maxWidth,
+			src,
+			status,
+			width
+		}).updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { img: () => ({
+			conversion: $convertImageElement,
+			priority: 0
+		}) };
+	}
+	decorate() {
+		return ImageNode._decorate(this);
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			status: this.__status
+		};
+	}
+};
+function $createImageNode({ altText, height, maxWidth = 500, src, width, key, status }) {
+	return $applyNodeReplacement(new ImageNode({
+		altText,
+		height,
+		key,
+		maxWidth,
+		src,
+		status,
+		width
+	}));
+}
+function $convertImageElement(domNode) {
+	const img = domNode;
+	if (img.src.startsWith("file:///")) return null;
+	const { alt: altText, src, width, height } = img;
+	return { node: $createImageNode({
+		altText,
+		height,
+		src,
+		width
+	}) };
+}
+function $isImageNode(node) {
+	return node.getType() === ImageNode.getType();
+}
+//#endregion
+//#region src/plugins/image/command/index.ts
+const logger$1 = createDebugLogger("plugin", "image");
+const INSERT_IMAGE_COMMAND = createCommand("INSERT_IMAGE_COMMAND");
+function isImageFile(file) {
+	return file.type.startsWith("image/");
+}
+function registerImageCommand(editor, handleUpload, defaultBlockImage = false) {
+	return editor.registerCommand(INSERT_IMAGE_COMMAND, (payload) => {
+		const { file, range, block, maxWidth } = payload;
+		const isBlock = block ?? defaultBlockImage;
+		if (!isImageFile(file)) return false;
+		const placeholderURL = URL.createObjectURL(file);
 		editor.update(() => {
-			if (expandTo) {
-				const selection = $getSelection();
-				if ($isRangeSelection(selection)) {
-					const anchorNode = selection.anchor.getNode();
-					selection.anchor.set(anchorNode.getKey(), expandTo.index, "text");
-					selection.focus.set(anchorNode.getKey(), expandTo.index + expandTo.length, "text");
-				}
+			if (range) {
+				const rangeSelection = $createRangeSelection();
+				if (range !== null && range !== void 0) rangeSelection.applyDOMRange(range);
+				$setSelection(rangeSelection);
 			}
-			editor.dispatchCommand(TOGGLE_LINK_COMMAND, nextUrl);
+			const imageNode = isBlock ? $createBlockImageNode({
+				altText: file.name,
+				maxWidth: maxWidth || 800,
+				src: placeholderURL,
+				status: "loading"
+			}) : $createImageNode({
+				altText: file.name,
+				maxWidth: maxWidth || 800,
+				src: placeholderURL,
+				status: "loading"
+			});
+			$insertNodes([imageNode]);
+			if (!isBlock && $isRootOrShadowRoot(imageNode.getParentOrThrow())) $wrapNodeInElement(imageNode, $createParagraphNode).selectEnd();
+			handleUpload(file).then((res) => {
+				editor.update(() => {
+					imageNode.setUploaded(res.url);
+				});
+			}).catch((error) => {
+				logger$1.error("❌ Image upload failed:", error);
+				editor.update(() => {
+					imageNode.setError("Image upload failed : " + error.message);
+				});
+			});
 		});
-	}, {
-		enabled: enableHotkey,
-		preventDefault: true,
-		stopPropagation: true
-	}));
-	return mergeRegister(...registrations);
+		return true;
+	}, COMMAND_PRIORITY_EDITOR);
 }
 //#endregion
-//#region src/plugins/link/plugin/index.ts
-const LinkPlugin = class extends KernelPlugin {
+//#region src/plugins/image/plugin/index.ts
+const ImagePlugin = class extends KernelPlugin {
 	static {
-		this.pluginName = "LinkPlugin";
+		this.pluginName = "ImagePlugin";
 	}
 	constructor(kernel, config) {
 		super();
 		this.kernel = kernel;
 		this.config = config;
-		this.linkRegex = /^https?:\/\/\S+$/;
-		this.service = new LinkService();
-		kernel.registerNodes([LinkNode, AutoLinkNode]);
-		kernel.registerService(ILinkService, this.service);
+		kernel.registerNodes([ImageNode, BlockImageNode]);
+		ImageNode.setDecorate(config?.renderImage ?? (() => null));
+		BlockImageNode.setDecorate(config?.renderImage ?? (() => null));
 		if (config?.theme) kernel.registerThemes(config.theme);
-		if (config?.linkRegex) this.linkRegex = config.linkRegex;
 	}
 	onInit(editor) {
-		this.register(registerLinkCommand(editor));
-		this.register(registerLinkCommands(editor, this.kernel, {
-			attributes: this.config?.attributes,
-			enableHotkey: this.config?.enableHotkey,
-			validateUrl: this.config?.validateUrl
-		}));
-		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.linkRegex.test(data)) {
-					payload.stopImmediatePropagation();
-					payload.preventDefault();
-					editor.dispatchCommand(INSERT_LINK_COMMAND, { url: data });
-					return true;
-				}
-			}
-			return false;
-		}, COMMAND_PRIORITY_NORMAL));
+		if (this.config?.handleUpload) this.register(registerImageCommand(editor, this.config.handleUpload, this.config?.defaultBlockImage !== false));
 		this.registerMarkdown();
 		this.registerLiteXml();
+		this.registerINode();
+		this.registerUpload(editor);
+		if (this.config?.needRehost && this.config?.handleRehost) {
+			const needRehost = this.config.needRehost;
+			const handleRehost = this.config.handleRehost;
+			this.register(editor.registerNodeTransform(ImageNode, (node) => {
+				if (node.status === "uploaded" && needRehost(node.src)) {
+					node.setStatus("loading");
+					handleRehost(node.src).then(({ url }) => {
+						editor.update(() => {
+							node.setUploaded(url);
+						});
+					}).catch(() => {
+						editor.update(() => {
+							node.setError("Rehost failed");
+						});
+					});
+				}
+			}));
+			this.register(editor.registerNodeTransform(BlockImageNode, (node) => {
+				if (node.status === "uploaded" && needRehost(node.src)) {
+					node.setStatus("loading");
+					handleRehost(node.src).then(({ url }) => {
+						editor.update(() => {
+							node.setUploaded(url);
+						});
+					}).catch(() => {
+						editor.update(() => {
+							node.setError("Rehost failed");
+						});
+					});
+				}
+			}));
+		}
+	}
+	registerUpload(editor) {
+		const uploadService = this.kernel.requireService(IUploadService);
+		if (!uploadService) return;
+		if (!this.config?.handleUpload) return;
+		uploadService.registerUpload(async (file, from, range) => {
+			const imageWidth = await this.config?.getImageWidth?.(file);
+			return editor.dispatchCommand(INSERT_IMAGE_COMMAND, {
+				block: this.config?.defaultBlockImage !== false,
+				file,
+				maxWidth: imageWidth,
+				range
+			});
+		}, 0);
 	}
 	registerLiteXml() {
 		const litexmlService = this.kernel.requireService(ILitexmlService);
 		if (!litexmlService) return;
-		litexmlService.registerXMLWriter(LinkNode.getType(), (node, ctx) => {
-			if ($isLinkNode(node)) {
-				const attributes = { href: node.getURL() };
-				return ctx.createXmlNode("a", attributes);
+		litexmlService.registerXMLWriter(ImageNode.getType(), (node, ctx) => {
+			if ($isImageNode(node)) {
+				const attributes = { src: node.src };
+				if (node.altText) attributes.alt = node.altText;
+				return ctx.createXmlNode("img", attributes);
 			}
 			return false;
 		});
-		litexmlService.registerXMLReader("a", (xmlNode, children) => {
-			return [INodeHelper.createElementNode("link", {
-				children,
-				direction: "ltr",
-				format: "",
-				indent: 0,
-				type: "link",
-				url: xmlNode.getAttribute("href") || "",
-				version: 1
-			})];
+		litexmlService.registerXMLWriter(BlockImageNode.getType(), (node, ctx) => {
+			if ($isBlockImageNode(node)) {
+				const attributes = {
+					block: "true",
+					src: node.src
+				};
+				if (node.altText) attributes.alt = node.altText;
+				if (node.width) attributes.width = String(node.width);
+				if (node.maxWidth) attributes["max-width"] = String(node.maxWidth);
+				return ctx.createXmlNode("img", attributes);
+			}
+			return false;
+		});
+		litexmlService.registerXMLReader("img", (xmlNode) => {
+			if (this.config?.defaultBlockImage !== false) return INodeHelper.createElementNode(BlockImageNode.getType(), {
+				altText: xmlNode.getAttribute("alt") || "",
+				maxWidth: xmlNode.getAttribute("max-width") ? parseInt(xmlNode.getAttribute("max-width"), 10) : void 0,
+				src: xmlNode.getAttribute("src") || "",
+				width: xmlNode.getAttribute("width") ? parseInt(xmlNode.getAttribute("width"), 10) : void 0
+			});
+			if (xmlNode.getAttribute("block") === "true") return INodeHelper.createElementNode(BlockImageNode.getType(), {
+				altText: xmlNode.getAttribute("alt") || "",
+				maxWidth: xmlNode.getAttribute("max-width") ? parseInt(xmlNode.getAttribute("max-width"), 10) : void 0,
+				src: xmlNode.getAttribute("src") || "",
+				width: xmlNode.getAttribute("width") ? parseInt(xmlNode.getAttribute("width"), 10) : void 0
+			});
+			else return INodeHelper.createElementNode(ImageNode.getType(), {
+				altText: xmlNode.getAttribute("alt") || "",
+				maxWidth: xmlNode.getAttribute("max-width") ? parseInt(xmlNode.getAttribute("max-width"), 10) : void 0,
+				src: xmlNode.getAttribute("src") || "",
+				width: xmlNode.getAttribute("width") ? parseInt(xmlNode.getAttribute("width"), 10) : void 0
+			});
 		});
 	}
 	registerMarkdown() {
-		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownShortCut({
-			regExp: /\[([^[]+)]\(([^\s()]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?\)\s?$/,
-			replace: (textNode, match) => {
-				const [, linkText, linkUrl, linkTitle] = match;
-				const linkNode = $createLinkNode(linkUrl, { title: linkTitle });
-				const linkTextNode = $createTextNode(linkText);
-				linkTextNode.setFormat(textNode.getFormat());
-				linkNode.append(linkTextNode);
-				textNode.replace(linkNode);
-				return linkTextNode;
-			},
-			trigger: ")",
-			type: "text-match"
+		const defaultBlockImage = this.config?.defaultBlockImage !== false;
+		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
+		if (!markdownService) return;
+		markdownService.registerMarkdownWriter(ImageNode.getType(), (ctx, node) => {
+			if ($isImageNode(node)) ctx.appendLine(`![${node.altText}](${node.src})`);
+		});
+		markdownService.registerMarkdownWriter(BlockImageNode.getType(), (ctx, node) => {
+			if ($isBlockImageNode(node)) ctx.appendLine(`![${node.altText}](${node.src})\n\n`);
+		});
+		markdownService.registerMarkdownReader("image", (node) => {
+			const altText = node.alt;
+			const src = node.url;
+			return INodeHelper.createTypeNode(defaultBlockImage ? BlockImageNode.getType() : ImageNode.getType(), {
+				altText,
+				showCaption: false,
+				src,
+				version: 1
+			});
+		});
+	}
+	registerINode() {
+		const service = this.kernel.requireService(INodeService);
+		if (!service) return;
+		service.registerProcessNodeTree(({ root }) => {
+			const loopNodes = (node) => {
+				if ("children" in node && Array.isArray(node.children)) {
+					if (node.type === "paragraph" && node.children.length === 1 && node.children[0].type === BlockImageNode.getType()) return node.children[0];
+					node.children = node.children.map((child) => {
+						return loopNodes(child);
+					});
+				}
+				return node;
+			};
+			root.children = root.children.map((child) => {
+				return loopNodes(child);
+			});
+		});
+	}
+};
+//#endregion
+//#region src/plugins/link/node/LinkNode.ts
+const logger = createDebugLogger("plugin", "link");
+const SUPPORTED_URL_PROTOCOLS$1 = new Set([
+	"http:",
+	"https:",
+	"mailto:",
+	"sms:",
+	"tel:"
+]);
+const HOVER_LINK_COMMAND = createCommand("HOVER_LINK_COMMAND");
+const HOVER_OUT_LINK_COMMAND = createCommand("HOVER_OUT_LINK_COMMAND");
+/** @noInheritDoc */
+var LinkNode = class LinkNode extends ElementNode {
+	static getType() {
+		return "link";
+	}
+	static clone(node) {
+		return new LinkNode(node.__url, {
+			rel: node.__rel,
+			target: node.__target,
+			title: node.__title
+		}, node.__key);
+	}
+	constructor(url = "", attributes = {}, key) {
+		super(key);
+		const { target = null, rel = null, title = null } = attributes;
+		this.__url = url;
+		this.__target = target;
+		this.__rel = rel;
+		this.__title = title;
+	}
+	createDOM(config, editor) {
+		logger.debug("🔍 config", config);
+		const element = document.createElement("a");
+		this.updateLinkDOM(null, element, config);
+		addClassNamesToElement(element, config.theme.link);
+		element.addEventListener("mouseenter", (event) => {
+			if (event.target instanceof HTMLElement) {
+				event.target.classList.add("hover");
+				editor.dispatchCommand(HOVER_LINK_COMMAND, {
+					event,
+					linkNode: this
+				});
+			}
+		});
+		element.addEventListener("mouseleave", (event) => {
+			if (event.target instanceof HTMLElement) {
+				event.target.classList.remove("hover");
+				editor.dispatchCommand(HOVER_OUT_LINK_COMMAND, { event });
+			}
+		});
+		return element;
+	}
+	updateLinkDOM(prevNode, anchor, _config) {
+		if (isHTMLAnchorElement(anchor)) {
+			if (!prevNode || prevNode.__url !== this.__url) anchor.href = this.sanitizeUrl(this.__url);
+			for (const attr of [
+				"target",
+				"rel",
+				"title"
+			]) {
+				const key = `__${attr}`;
+				const value = this[key];
+				if (!prevNode || prevNode[key] !== value) if (value) anchor[attr] = value;
+				else anchor.removeAttribute(attr);
+			}
+		}
+	}
+	updateDOM(prevNode, anchor, config) {
+		this.updateLinkDOM(prevNode, anchor, config);
+		return false;
+	}
+	static importDOM() {
+		return { a: () => ({
+			conversion: $convertAnchorElement,
+			priority: 1
+		}) };
+	}
+	static importJSON(serializedNode) {
+		return $createLinkNode().updateFromJSON(serializedNode);
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode).setURL(serializedNode.url).setRel(serializedNode.rel || null).setTarget(serializedNode.target || null).setTitle(serializedNode.title || null);
+	}
+	sanitizeUrl(url) {
+		url = formatUrl(url);
+		try {
+			const parsedUrl = new URL(formatUrl(url));
+			if (!SUPPORTED_URL_PROTOCOLS$1.has(parsedUrl.protocol)) return "about:blank";
+		} catch {
+			return url;
+		}
+		return url;
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			rel: this.getRel(),
+			target: this.getTarget(),
+			title: this.getTitle(),
+			url: this.getURL()
+		};
+	}
+	getURL() {
+		return this.getLatest().__url;
+	}
+	setURL(url) {
+		const writable = this.getWritable();
+		writable.__url = url;
+		return writable;
+	}
+	getTarget() {
+		return this.getLatest().__target;
+	}
+	setTarget(target) {
+		const writable = this.getWritable();
+		writable.__target = target;
+		return writable;
+	}
+	getRel() {
+		return this.getLatest().__rel;
+	}
+	setRel(rel) {
+		const writable = this.getWritable();
+		writable.__rel = rel;
+		return writable;
+	}
+	getTitle() {
+		return this.getLatest().__title;
+	}
+	setTitle(title) {
+		const writable = this.getWritable();
+		writable.__title = title;
+		return writable;
+	}
+	insertNewAfter(_, restoreSelection = true) {
+		const linkNode = $createLinkNode(this.__url, {
+			rel: this.__rel,
+			target: this.__target,
+			title: this.__title
+		});
+		this.insertAfter(linkNode, restoreSelection);
+		return linkNode;
+	}
+	canInsertTextBefore() {
+		return false;
+	}
+	canInsertTextAfter() {
+		return false;
+	}
+	canBeEmpty() {
+		return false;
+	}
+	isInline() {
+		return true;
+	}
+	extractWithChild(child, selection) {
+		if (!$isRangeSelection(selection)) return false;
+		const anchorNode = selection.anchor.getNode();
+		const focusNode = selection.focus.getNode();
+		return this.isParentOf(anchorNode) && this.isParentOf(focusNode) && selection.getTextContent().length > 0;
+	}
+	isEmailURI() {
+		return this.__url.startsWith("mailto:");
+	}
+	isWebSiteURI() {
+		return this.__url.startsWith("https://") || this.__url.startsWith("http://");
+	}
+};
+function $convertAnchorElement(domNode) {
+	let node = null;
+	if (isHTMLAnchorElement(domNode)) {
+		const content = domNode.textContent;
+		if (content !== null && content !== "" || domNode.children.length > 0) node = $createLinkNode(domNode.getAttribute("href") || "", {
+			rel: domNode.getAttribute("rel"),
+			target: domNode.getAttribute("target"),
+			title: domNode.getAttribute("title")
+		});
+	}
+	return { node };
+}
+/**
+* Takes a URL and creates a LinkNode.
+* @param url - The URL the LinkNode should direct to.
+* @param attributes - Optional HTML a tag attributes \\{ target, rel, title \\}
+* @returns The LinkNode.
+*/
+function $createLinkNode(url = "", attributes) {
+	return $applyNodeReplacement(new LinkNode(url, attributes));
+}
+/**
+* Determines if node is a LinkNode.
+* @param node - The node to be checked.
+* @returns true if node is a LinkNode, false otherwise.
+*/
+function $isLinkNode(node) {
+	return node instanceof LinkNode;
+}
+var AutoLinkNode = class AutoLinkNode extends LinkNode {
+	constructor(url = "", attributes = {}, key) {
+		super(url, attributes, key);
+		this.__isUnlinked = attributes.isUnlinked !== void 0 && attributes.isUnlinked !== null ? attributes.isUnlinked : false;
+	}
+	static getType() {
+		return "autolink";
+	}
+	static clone(node) {
+		return new AutoLinkNode(node.__url, {
+			isUnlinked: node.__isUnlinked,
+			rel: node.__rel,
+			target: node.__target,
+			title: node.__title
+		}, node.__key);
+	}
+	getIsUnlinked() {
+		return this.__isUnlinked;
+	}
+	setIsUnlinked(value) {
+		const self = this.getWritable();
+		self.__isUnlinked = value;
+		return self;
+	}
+	createDOM(config, editor) {
+		logger.debug("🔍 config", config);
+		if (this.__isUnlinked) return document.createElement("span");
+		else return super.createDOM(config, editor);
+	}
+	updateDOM(prevNode, anchor, config) {
+		return super.updateDOM(prevNode, anchor, config) || prevNode.__isUnlinked !== this.__isUnlinked;
+	}
+	static importJSON(serializedNode) {
+		return $createAutoLinkNode().updateFromJSON(serializedNode);
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode).setIsUnlinked(serializedNode.isUnlinked || false);
+	}
+	static importDOM() {
+		return null;
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			isUnlinked: this.__isUnlinked
+		};
+	}
+	insertNewAfter(selection, restoreSelection = true) {
+		const element = this.getParentOrThrow().insertNewAfter(selection, restoreSelection);
+		if ($isElementNode(element)) {
+			const linkNode = $createAutoLinkNode(this.__url, {
+				isUnlinked: this.__isUnlinked,
+				rel: this.__rel,
+				target: this.__target,
+				title: this.__title
+			});
+			element.append(linkNode);
+			return linkNode;
+		}
+		return null;
+	}
+};
+/**
+* Takes a URL and creates an AutoLinkNode. AutoLinkNodes are generally automatically generated
+* during typing, which is especially useful when a button to generate a LinkNode is not practical.
+* @param url - The URL the LinkNode should direct to.
+* @param attributes - Optional HTML a tag attributes. \\{ target, rel, title \\}
+* @returns The LinkNode.
+*/
+function $createAutoLinkNode(url = "", attributes) {
+	return $applyNodeReplacement(new AutoLinkNode(url, attributes));
+}
+/**
+* Determines if node is an AutoLinkNode.
+* @param node - The node to be checked.
+* @returns true if node is an AutoLinkNode, false otherwise.
+*/
+function $isAutoLinkNode(node) {
+	return node instanceof AutoLinkNode;
+}
+const TOGGLE_LINK_COMMAND = createCommand("TOGGLE_LINK_COMMAND");
+function $getPointNode(point, offset) {
+	if (point.type === "element") {
+		const node = point.getNode();
+		assert($isElementNode(node), "$getPointNode: element point is not an ElementNode");
+		return node.getChildren()[point.offset + offset] || null;
+	}
+	return null;
+}
+/**
+* Preserve the logical start/end of a RangeSelection in situations where
+* the point is an element that may be reparented in the callback.
+*
+* @param $fn The function to run
+* @returns The result of the callback
+*/
+function $withSelectedNodes($fn) {
+	const initialSelection = $getSelection();
+	if (!$isRangeSelection(initialSelection)) return $fn();
+	const normalized = $normalizeSelection__EXPERIMENTAL(initialSelection);
+	const isBackwards = normalized.isBackward();
+	const anchorNode = $getPointNode(normalized.anchor, isBackwards ? -1 : 0);
+	const focusNode = $getPointNode(normalized.focus, isBackwards ? 0 : -1);
+	const rval = $fn();
+	if (anchorNode || focusNode) {
+		const updatedSelection = $getSelection();
+		if ($isRangeSelection(updatedSelection)) {
+			const finalSelection = updatedSelection.clone();
+			if (anchorNode) {
+				const anchorParent = anchorNode.getParent();
+				if (anchorParent) finalSelection.anchor.set(anchorParent.getKey(), anchorNode.getIndexWithinParent() + (isBackwards ? 1 : 0), "element");
+			}
+			if (focusNode) {
+				const focusParent = focusNode.getParent();
+				if (focusParent) finalSelection.focus.set(focusParent.getKey(), focusNode.getIndexWithinParent() + (isBackwards ? 0 : 1), "element");
+			}
+			$setSelection($normalizeSelection__EXPERIMENTAL(finalSelection));
+		}
+	}
+	return rval;
+}
+/**
+* Generates or updates a LinkNode. It can also delete a LinkNode if the URL is null,
+* but saves any children and brings them up to the parent node.
+* @param url - The URL the link directs to.
+* @param attributes - Optional HTML a tag attributes. \\{ target, rel, title \\}
+*/
+function $toggleLink(url, attributes = {}) {
+	const { target, title } = attributes;
+	const rel = attributes.rel === void 0 ? "noreferrer" : attributes.rel;
+	const selection = $getSelection();
+	if (selection === null || !$isRangeSelection(selection) && !$isNodeSelection(selection)) return;
+	if ($isNodeSelection(selection)) {
+		const nodes = selection.getNodes();
+		if (nodes.length === 0) return;
+		nodes.forEach((node) => {
+			if (url === null) {
+				const linkParent = $findMatchingParent(node, (parent) => !$isAutoLinkNode(parent) && $isLinkNode(parent));
+				if (linkParent) {
+					linkParent.insertBefore(node);
+					if (linkParent.getChildren().length === 0) linkParent.remove();
+				}
+			} else {
+				const existingLink = $findMatchingParent(node, (parent) => !$isAutoLinkNode(parent) && $isLinkNode(parent));
+				if (existingLink) {
+					existingLink.setURL(url);
+					if (target !== void 0) existingLink.setTarget(target);
+					if (rel !== void 0) existingLink.setRel(rel);
+				} else {
+					const linkNode = $createLinkNode(url, {
+						rel,
+						target
+					});
+					node.insertBefore(linkNode);
+					linkNode.append(node);
+				}
+			}
+		});
+		return;
+	}
+	const nodes = selection.extract();
+	if (url === null) {
+		nodes.forEach((node) => {
+			const parentLink = $findMatchingParent(node, (parent) => !$isAutoLinkNode(parent) && $isLinkNode(parent));
+			if (parentLink) {
+				const children = parentLink.getChildren();
+				for (const child of children) parentLink.insertBefore(child);
+				parentLink.remove();
+			}
+		});
+		return;
+	}
+	const updatedNodes = /* @__PURE__ */ new Set();
+	const updateLinkNode = (linkNode) => {
+		if (updatedNodes.has(linkNode.getKey())) return;
+		updatedNodes.add(linkNode.getKey());
+		linkNode.setURL(url);
+		if (target !== void 0) linkNode.setTarget(target);
+		if (rel !== void 0) linkNode.setRel(rel);
+		if (title !== void 0) linkNode.setTitle(title);
+	};
+	if (nodes.length === 1) {
+		const firstNode = nodes[0];
+		const linkNode = $getAncestor(firstNode, $isLinkNode);
+		if (linkNode !== null) return updateLinkNode(linkNode);
+	}
+	$withSelectedNodes(() => {
+		let linkNode = null;
+		for (const node of nodes) {
+			if (!node.isAttached()) continue;
+			const parentLinkNode = $getAncestor(node, $isLinkNode);
+			if (parentLinkNode) {
+				updateLinkNode(parentLinkNode);
+				continue;
+			}
+			if ($isElementNode(node)) {
+				if (!node.isInline()) continue;
+				if ($isLinkNode(node)) {
+					if (!$isAutoLinkNode(node) && (linkNode === null || !linkNode.getParentOrThrow().isParentOf(node))) {
+						updateLinkNode(node);
+						linkNode = node;
+						continue;
+					}
+					for (const child of node.getChildren()) node.insertBefore(child);
+					node.remove();
+					continue;
+				}
+			}
+			const prevLinkNode = node.getPreviousSibling();
+			if ($isLinkNode(prevLinkNode) && prevLinkNode.is(linkNode)) {
+				prevLinkNode.append(node);
+				continue;
+			}
+			linkNode = $createLinkNode(url, {
+				rel,
+				target,
+				title
+			});
+			node.insertAfter(linkNode);
+			linkNode.append(node);
+		}
+	});
+}
+function $getAncestor(node, predicate) {
+	let parent = node;
+	while (parent !== null && parent.getParent() !== null && !predicate(parent)) parent = parent.getParentOrThrow();
+	return predicate(parent) ? parent : null;
+}
+const PHONE_NUMBER_REGEX = /^\+?[\d\s()-]{5,}$/;
+/**
+* Formats a URL string by adding appropriate protocol if missing
+*
+* @param url - URL to format
+* @returns Formatted URL with appropriate protocol
+*/
+function formatUrl(url) {
+	if (/^[a-z][\d+.a-z-]*:/i.test(url)) return url;
+	else if (/^[#./]/.test(url)) return url;
+	else if (url.includes("@")) return `mailto:${url}`;
+	else if (PHONE_NUMBER_REGEX.test(url)) return `tel:${url}`;
+	return url;
+}
+//#endregion
+//#region src/plugins/link/command/index.ts
+const INSERT_LINK_COMMAND = createCommand("INSERT_LINK_COMMAND");
+const UPDATE_LINK_TEXT_COMMAND = createCommand("UPDATE_LINK_TEXT_COMMAND");
+function registerLinkCommand(editor) {
+	return mergeRegister(editor.registerCommand(INSERT_LINK_COMMAND, (payload) => {
+		const { url, title = url } = payload;
+		editor.update(() => {
+			const linkNode = $createLinkNode(url, { title });
+			const textNode = $createTextNode(title);
+			linkNode.append(textNode);
+			$insertNodes([linkNode]);
+		});
+		return false;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(UPDATE_LINK_TEXT_COMMAND, (payload) => {
+		const { key, text } = payload;
+		editor.update(() => {
+			const linkNode = $getNodeByKey(key);
+			if (linkNode) {
+				const newLinkNode = $createLinkNode(linkNode.getURL(), { title: text });
+				const textNode = $createTextNode(text);
+				newLinkNode.append(textNode);
+				linkNode?.replace(newLinkNode);
+				newLinkNode.select(1);
+			}
+		});
+		return false;
+	}, COMMAND_PRIORITY_EDITOR));
+}
+//#endregion
+//#region src/plugins/link/service/i-link-service.ts
+const ILinkService = genServiceId("LinkService");
+var LinkService = class extends EventEmitter {
+	constructor(..._args) {
+		super(..._args);
+		this._enableLinkToolbar = true;
+	}
+	get enableLinkToolbar() {
+		return this._enableLinkToolbar;
+	}
+	setLinkToolbar(enable) {
+		this._enableLinkToolbar = enable;
+		this.emit("linkToolbarChange", enable);
+	}
+};
+//#endregion
+//#region src/plugins/link/utils/index.ts
+const SUPPORTED_URL_PROTOCOLS = new Set([
+	"http:",
+	"https:",
+	"mailto:",
+	"sms:",
+	"tel:"
+]);
+function sanitizeUrl(url) {
+	try {
+		const parsedUrl = new URL(url);
+		if (!SUPPORTED_URL_PROTOCOLS.has(parsedUrl.protocol)) return "about:blank";
+	} catch {
+		return url;
+	}
+	return url;
+}
+const urlRegExp = /* @__PURE__ */ new RegExp(/((([A-Za-z]{3,9}:(?:\/\/)?)(?:[\w$&+,:;=-]+@)?[\d.A-Za-z-]+|(?:www.|[\w$&+,:;=-]+@)[\d.A-Za-z-]+)((?:\/[%+./~\w-_]*)?\??[\w%&+.;=@-]*#?\w*)?)/);
+function extractUrlFromText(text) {
+	const match = urlRegExp.exec(text);
+	if (!match) return null;
+	const raw = match[0];
+	const start = match.index ?? text.indexOf(raw);
+	const trimmed = raw.replace(/[)\],.;:]+$/u, "");
+	return {
+		index: start,
+		length: trimmed.length,
+		url: trimmed
+	};
+}
+function getSelectedNode(selection) {
+	const anchor = selection.anchor;
+	const focus = selection.focus;
+	const anchorNode = selection.anchor.getNode();
+	const focusNode = selection.focus.getNode();
+	if (anchorNode === focusNode) return anchorNode;
+	if (selection.isBackward()) return $isAtNodeEnd(focus) ? anchorNode : focusNode;
+	else return $isAtNodeEnd(anchor) ? anchorNode : focusNode;
+}
+//#endregion
+//#region src/plugins/link/plugin/registry.ts
+function registerLinkCommands(editor, kernel, options) {
+	const { validateUrl, attributes, enableHotkey = true } = options || {};
+	const state = { isLink: false };
+	const registrations = [editor.registerUpdateListener(() => {
+		const selection = editor.getEditorState().read(() => $getSelection());
+		if (!selection) return;
+		if ($isRangeSelection(selection)) editor.getEditorState().read(() => {
+			const node = getSelectedNode(selection);
+			state.isLink = $isLinkNode(node.getParent()) || $isLinkNode(node);
+		});
+		else state.isLink = false;
+	}), editor.registerCommand(TOGGLE_LINK_COMMAND, (payload) => {
+		if (payload === null) {
+			$toggleLink(payload);
+			return true;
+		} else if (typeof payload === "string") {
+			if (validateUrl === void 0 || validateUrl(payload)) {
+				$toggleLink(payload, attributes);
+				return true;
+			}
+			return false;
+		} else {
+			const { url, target, rel, title } = payload;
+			$toggleLink(url, {
+				...attributes,
+				rel,
+				target,
+				title
+			});
+			return true;
+		}
+	}, COMMAND_PRIORITY_LOW)];
+	registrations.push(kernel.registerHotkey(HotkeyEnum.Link, () => {
+		if (state.isLink) {
+			editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+			return;
+		}
+		let nextUrl = sanitizeUrl("https://");
+		let expandTo = null;
+		editor.getEditorState().read(() => {
+			const selection = $getSelection();
+			if ($isRangeSelection(selection)) if (!selection.isCollapsed()) {
+				const maybeUrl = formatUrl(selection.getTextContent().trim());
+				if (validateUrl?.(maybeUrl)) nextUrl = maybeUrl;
+			} else {
+				const found = extractUrlFromText(selection.anchor.getNode().getTextContent());
+				if (found && validateUrl?.(formatUrl(found.url))) {
+					nextUrl = formatUrl(found.url);
+					expandTo = {
+						index: found.index,
+						length: found.length
+					};
+				}
+			}
+		});
+		editor.update(() => {
+			if (expandTo) {
+				const selection = $getSelection();
+				if ($isRangeSelection(selection)) {
+					const anchorNode = selection.anchor.getNode();
+					selection.anchor.set(anchorNode.getKey(), expandTo.index, "text");
+					selection.focus.set(anchorNode.getKey(), expandTo.index + expandTo.length, "text");
+				}
+			}
+			editor.dispatchCommand(TOGGLE_LINK_COMMAND, nextUrl);
+		});
+	}, {
+		enabled: enableHotkey,
+		preventDefault: true,
+		stopPropagation: true
+	}));
+	return mergeRegister(...registrations);
+}
+//#endregion
+//#region src/plugins/link/plugin/index.ts
+const LinkPlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "LinkPlugin";
+	}
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		this.config = config;
+		this.linkRegex = /^https?:\/\/\S+$/;
+		this.service = new LinkService();
+		kernel.registerNodes([LinkNode, AutoLinkNode]);
+		kernel.registerService(ILinkService, this.service);
+		if (config?.theme) kernel.registerThemes(config.theme);
+		if (config?.linkRegex) this.linkRegex = config.linkRegex;
+	}
+	onInit(editor) {
+		this.register(registerLinkCommand(editor));
+		this.register(registerLinkCommands(editor, this.kernel, {
+			attributes: this.config?.attributes,
+			enableHotkey: this.config?.enableHotkey,
+			validateUrl: this.config?.validateUrl
+		}));
+		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.linkRegex.test(data)) {
+					payload.stopImmediatePropagation();
+					payload.preventDefault();
+					editor.dispatchCommand(INSERT_LINK_COMMAND, { url: data });
+					return true;
+				}
+			}
+			return false;
+		}, COMMAND_PRIORITY_NORMAL));
+		this.registerMarkdown();
+		this.registerLiteXml();
+	}
+	registerLiteXml() {
+		const litexmlService = this.kernel.requireService(ILitexmlService);
+		if (!litexmlService) return;
+		litexmlService.registerXMLWriter(LinkNode.getType(), (node, ctx) => {
+			if ($isLinkNode(node)) {
+				const attributes = { href: node.getURL() };
+				return ctx.createXmlNode("a", attributes);
+			}
+			return false;
+		});
+		litexmlService.registerXMLReader("a", (xmlNode, children) => {
+			return [INodeHelper.createElementNode("link", {
+				children,
+				direction: "ltr",
+				format: "",
+				indent: 0,
+				type: "link",
+				url: xmlNode.getAttribute("href") || "",
+				version: 1
+			})];
+		});
+	}
+	registerMarkdown() {
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownShortCut({
+			regExp: /\[([^[]+)]\(([^\s()]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?\)\s?$/,
+			replace: (textNode, match) => {
+				const [, linkText, linkUrl, linkTitle] = match;
+				const linkNode = $createLinkNode(linkUrl, { title: linkTitle });
+				const linkTextNode = $createTextNode(linkText);
+				linkTextNode.setFormat(textNode.getFormat());
+				linkNode.append(linkTextNode);
+				textNode.replace(linkNode);
+				return linkTextNode;
+			},
+			trigger: ")",
+			type: "text-match"
 		});
 		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(LinkNode.getType(), (ctx, node) => {
 			if ($isLinkNode(node)) ctx.wrap("[", `](${node.getURL()})`);
 		});
-		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownReader("link", (node, children) => {
-			return [INodeHelper.createElementNode("link", {
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownReader("link", (node, children) => {
+			return [INodeHelper.createElementNode("link", {
+				children,
+				direction: "ltr",
+				format: "",
+				indent: 0,
+				title: node.title || void 0,
+				type: "link",
+				url: node.url || "",
+				version: 1
+			})];
+		});
+	}
+};
+//#endregion
+//#region src/utils/cx.ts
+const cx = (...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/checkList.ts
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+const INSERT_CHECK_LIST_COMMAND = createCommand("INSERT_CHECK_LIST_COMMAND");
+function isHeadlessEditor$1(editor) {
+	return editor._headless === true;
+}
+function handleCheckItemEvent(event, callback) {
+	const target = event.target;
+	if (!isHTMLElement$1(target)) return;
+	const firstChild = target.firstChild;
+	if (isHTMLElement$1(firstChild) && (firstChild.tagName === "UL" || firstChild.tagName === "OL")) return;
+	const parentNode = target.parentNode;
+	if (!parentNode || parentNode.__lexicalListType !== "check") return;
+	const rect = target.getBoundingClientRect();
+	const zoom = calculateZoomLevel(target);
+	const clientX = event.clientX / zoom;
+	const beforeStyles = window.getComputedStyle ? window.getComputedStyle(target, "::before") : { width: "0px" };
+	const beforeWidthInPixels = parseFloat(beforeStyles.width);
+	const beforeMargin = parseFloat(beforeStyles.marginLeft);
+	const clickAreaPadding = event.pointerType === "touch" ? 32 : 0;
+	if (target.dir === "rtl" ? clientX < rect.right + clickAreaPadding && clientX > rect.right - beforeWidthInPixels - clickAreaPadding : clientX > rect.left + beforeMargin - clickAreaPadding && clientX < rect.left + beforeMargin + beforeWidthInPixels + clickAreaPadding) callback();
+}
+function handleClick(event) {
+	handleCheckItemEvent(event, () => {
+		if (isHTMLElement$1(event.target)) {
+			const domNode = event.target;
+			const editor = getNearestEditorFromDOMNode(domNode);
+			if (editor && editor.isEditable()) editor.update(() => {
+				const node = $getNearestNodeFromDOMNode(domNode);
+				if ($isListItemNode(node)) {
+					domNode.focus();
+					node.toggleChecked();
+				}
+			});
+		}
+	});
+}
+function handlePointerDown(event) {
+	handleCheckItemEvent(event, () => {
+		event.preventDefault();
+	});
+}
+function getActiveCheckListItem() {
+	const activeElement = document.activeElement;
+	return isHTMLElement$1(activeElement) && activeElement.tagName === "LI" && activeElement.parentNode && activeElement.parentNode.__lexicalListType === "check" ? activeElement : null;
+}
+function findCheckListItemSibling(node, backward) {
+	let sibling = backward ? node.getPreviousSibling() : node.getNextSibling();
+	let parent = node;
+	while (!sibling && $isListItemNode(parent)) {
+		parent = parent.getParentOrThrow().getParent();
+		if (parent) sibling = backward ? parent.getPreviousSibling() : parent.getNextSibling();
+	}
+	while ($isListItemNode(sibling)) {
+		const firstChild = backward ? sibling.getLastChild() : sibling.getFirstChild();
+		if (!$isListNode(firstChild)) return sibling;
+		sibling = backward ? firstChild.getLastChild() : firstChild.getFirstChild();
+	}
+	return null;
+}
+function handleArrowUpOrDown(event, editor, backward) {
+	const activeItem = getActiveCheckListItem();
+	if (activeItem) editor.update(() => {
+		const listItem = $getNearestNodeFromDOMNode(activeItem);
+		if (!$isListItemNode(listItem)) return;
+		const nextListItem = findCheckListItemSibling(listItem, backward);
+		if (nextListItem) {
+			nextListItem.selectStart();
+			const dom = editor.getElementByKey(nextListItem.__key);
+			if (dom) {
+				event.preventDefault();
+				setTimeout(() => {
+					dom.focus();
+				}, 0);
+			}
+		}
+	});
+	return false;
+}
+function registerCheckList(editor) {
+	const registrations = [
+		editor.registerCommand(INSERT_CHECK_LIST_COMMAND, () => {
+			$insertList("check");
+			return true;
+		}, COMMAND_PRIORITY_LOW),
+		editor.registerCommand(KEY_ARROW_DOWN_COMMAND, (event) => {
+			return handleArrowUpOrDown(event, editor, false);
+		}, COMMAND_PRIORITY_LOW),
+		editor.registerCommand(KEY_ARROW_UP_COMMAND, (event) => {
+			return handleArrowUpOrDown(event, editor, true);
+		}, COMMAND_PRIORITY_LOW),
+		editor.registerCommand(KEY_ARROW_LEFT_COMMAND, (event) => {
+			return editor.getEditorState().read(() => {
+				const selection = $getSelection();
+				if ($isRangeSelection(selection) && selection.isCollapsed()) {
+					const { anchor } = selection;
+					const isElement = anchor.type === "element";
+					if (isElement || anchor.offset === 0) {
+						const anchorNode = anchor.getNode();
+						const elementNode = $findMatchingParent(anchorNode, (node) => $isElementNode(node) && !node.isInline());
+						if ($isListItemNode(elementNode)) {
+							const parent = elementNode.getParent();
+							if ($isListNode(parent) && parent.getListType() === "check" && (isElement || elementNode.getFirstDescendant() === anchorNode)) {
+								const domNode = editor.getElementByKey(elementNode.__key);
+								if (domNode && document.activeElement !== domNode) {
+									domNode.focus();
+									event.preventDefault();
+									return true;
+								}
+							}
+						}
+					}
+				}
+				return false;
+			});
+		}, COMMAND_PRIORITY_LOW)
+	];
+	if (!isHeadlessEditor$1(editor)) registrations.push(editor.registerRootListener((rootElement, prevElement) => {
+		if (rootElement !== null) {
+			rootElement.addEventListener("click", handleClick);
+			rootElement.addEventListener("pointerdown", handlePointerDown);
+		}
+		if (prevElement !== null) {
+			prevElement.removeEventListener("click", handleClick);
+			prevElement.removeEventListener("pointerdown", handlePointerDown);
+		}
+	}));
+	return mergeRegister(...registrations);
+}
+//#endregion
+//#region src/plugins/list/plugin/registry.ts
+function registerListCommands(editor, kernel, options) {
+	const { enableHotkey = true } = options || {};
+	return mergeRegister(kernel.registerHotkey(HotkeyEnum.BulletList, () => editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, void 0), {
+		enabled: enableHotkey,
+		preventDefault: true,
+		stopImmediatePropagation: true
+	}), kernel.registerHotkey(HotkeyEnum.NumberList, () => editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, 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
+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("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)
+		} });
+	}
+	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,
-				title: node.title || void 0,
-				type: "link",
-				url: node.url || "",
+				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/utils/cx.ts
-const cx = (...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);
-	};
+//#region src/plugins/math/node/index.ts
+var MathInlineNode = class MathInlineNode extends DecoratorNode {
+	static getType() {
+		return "math";
+	}
+	static clone(node) {
+		return new MathInlineNode(node.__code, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createMathInlineNode().updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { span: (node) => {
+			if (node.classList.contains("math-inline")) return {
+				conversion: $convertMathInlineElement,
+				priority: 0
+			};
+			return null;
+		} };
+	}
+	constructor(code = "", key) {
+		super(key);
+		this.__code = code;
+	}
+	get code() {
+		return this.__code;
+	}
+	updateCode(newCode) {
+		const writer = this.getWritable();
+		writer.__code = newCode;
+	}
+	exportDOM() {
+		const span = document.createElement("span");
+		span.className = "math-inline";
+		return { element: span };
+	}
+	createDOM(config) {
+		const element = document.createElement("span");
+		addClassNamesToElement(element, config.theme.mathInline);
+		return element;
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			code: this.__code
+		};
+	}
+	updateFromJSON(serializedNode) {
+		const node = super.updateFromJSON(serializedNode);
+		this.__code = serializedNode.code || "";
+		return node;
+	}
+	getTextContent() {
+		return `$${this.code}$`;
+	}
+	isInline() {
+		return true;
+	}
+	updateDOM() {
+		return false;
+	}
+	decorate(editor) {
+		const decorator = getKernelFromEditor(editor)?.getDecorator(MathInlineNode.getType());
+		if (!decorator) return null;
+		if (typeof decorator === "function") return decorator(this, editor);
+		return {
+			queryDOM: decorator.queryDOM,
+			render: decorator.render(this, editor)
+		};
+	}
 };
-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;
+var MathBlockNode = class MathBlockNode extends DecoratorNode {
+	static getType() {
+		return "mathBlock";
 	}
-	return false;
+	static clone(node) {
+		return new MathBlockNode(node.__code, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createMathBlockNode().updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { div: (node) => {
+			if (node.classList.contains("math-block")) return {
+				conversion: $convertMathBlockElement,
+				priority: 0
+			};
+			return null;
+		} };
+	}
+	constructor(code = "", key) {
+		super(key);
+		this.__code = code;
+	}
+	get code() {
+		return this.__code;
+	}
+	updateCode(newCode) {
+		const writer = this.getWritable();
+		writer.__code = newCode;
+	}
+	exportDOM() {
+		const div = document.createElement("div");
+		div.className = "math-block";
+		return { element: div };
+	}
+	createDOM(config) {
+		const element = document.createElement("div");
+		addClassNamesToElement(element, config.theme.mathBlock);
+		return element;
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			code: this.__code
+		};
+	}
+	updateFromJSON(serializedNode) {
+		const node = super.updateFromJSON(serializedNode);
+		this.__code = serializedNode.code || "";
+		return node;
+	}
+	getTextContent() {
+		return `$$\n${this.code}\n$$\n`;
+	}
+	isInline() {
+		return false;
+	}
+	updateDOM() {
+		return false;
+	}
+	decorate(editor) {
+		const decorator = getKernelFromEditor(editor)?.getDecorator(MathBlockNode.getType());
+		if (!decorator) return null;
+		if (typeof decorator === "function") return decorator(this, editor);
+		return {
+			queryDOM: decorator.queryDOM,
+			render: decorator.render(this, editor)
+		};
+	}
+};
+function $createMathInlineNode(code = "") {
+	return $applyNodeReplacement(new MathInlineNode(code));
+}
+function $createMathBlockNode(code = "") {
+	return $applyNodeReplacement(new MathBlockNode(code));
+}
+function $convertMathInlineElement() {
+	return { node: $createMathInlineNode() };
+}
+function $convertMathBlockElement() {
+	return { node: $createMathBlockNode() };
 }
 //#endregion
-//#region src/plugins/list/plugin/checkList.ts
+//#region src/plugins/math/command/index.ts
+const INSERT_MATH_COMMAND = createCommand("INSERT_MATH_COMMAND");
+const UPDATE_MATH_COMMAND = createCommand("UPDATE_MATH_COMMAND");
+const SELECT_MATH_SIDE_COMMAND = createCommand("SELECT_MATH_SIDE_COMMAND");
+function registerMathCommand(editor) {
+	return mergeRegister(editor.registerCommand(INSERT_MATH_COMMAND, (payload) => {
+		const { code } = payload;
+		editor.update(() => {
+			const mathNode = $createMathInlineNode(code);
+			$insertNodes([mathNode]);
+			if ($isRootOrShadowRoot(mathNode.getParentOrThrow())) $wrapNodeInElement(mathNode, $createParagraphNode).selectEnd();
+		});
+		return true;
+	}, COMMAND_PRIORITY_HIGH), editor.registerCommand(UPDATE_MATH_COMMAND, (payload) => {
+		const { code, key } = payload;
+		editor.update(() => {
+			const mathCode = $getNodeByKey(key);
+			if (mathCode) {
+				mathCode.updateCode(code);
+				mathCode.selectNext();
+			}
+		});
+		return true;
+	}, COMMAND_PRIORITY_HIGH), editor.registerCommand(SELECT_MATH_SIDE_COMMAND, (payload) => {
+		const { key, prev } = payload;
+		editor.update(() => {
+			const mathNode = $getNodeByKey(key);
+			if (mathNode) if (prev) mathNode.selectPrevious();
+			else mathNode.selectNext();
+		});
+		return true;
+	}, COMMAND_PRIORITY_HIGH));
+}
+//#endregion
+//#region src/plugins/math/utils/index.ts
 /**
-* Copyright (c) Meta Platforms, Inc. and affiliates.
+* Heuristic: does the content between `$...$` look like a math formula?
 *
-* This source code is licensed under the MIT license found in the
-* LICENSE file in the root directory of this source tree.
+* Positive signals (any one → math):
+*  - LaTeX commands        \alpha  \frac  …
+*  - Structural chars      ^ _ { } ( )
+*  - Operators / relations  + - * / = < > | ! ,
+*  - Digits                0-9
+*  - Single ASCII letter   x  y  n  (common math variable)
 *
+* Everything else (multi-char words, CJK, spaced plain text) → not math.
 */
-const INSERT_CHECK_LIST_COMMAND = createCommand("INSERT_CHECK_LIST_COMMAND");
-function isHeadlessEditor$1(editor) {
-	return editor._headless === true;
-}
-function handleCheckItemEvent(event, callback) {
-	const target = event.target;
-	if (!isHTMLElement$1(target)) return;
-	const firstChild = target.firstChild;
-	if (isHTMLElement$1(firstChild) && (firstChild.tagName === "UL" || firstChild.tagName === "OL")) return;
-	const parentNode = target.parentNode;
-	if (!parentNode || parentNode.__lexicalListType !== "check") return;
-	const rect = target.getBoundingClientRect();
-	const zoom = calculateZoomLevel(target);
-	const clientX = event.clientX / zoom;
-	const beforeStyles = window.getComputedStyle ? window.getComputedStyle(target, "::before") : { width: "0px" };
-	const beforeWidthInPixels = parseFloat(beforeStyles.width);
-	const beforeMargin = parseFloat(beforeStyles.marginLeft);
-	const clickAreaPadding = event.pointerType === "touch" ? 32 : 0;
-	if (target.dir === "rtl" ? clientX < rect.right + clickAreaPadding && clientX > rect.right - beforeWidthInPixels - clickAreaPadding : clientX > rect.left + beforeMargin - clickAreaPadding && clientX < rect.left + beforeMargin + beforeWidthInPixels + clickAreaPadding) callback();
-}
-function handleClick(event) {
-	handleCheckItemEvent(event, () => {
-		if (isHTMLElement$1(event.target)) {
-			const domNode = event.target;
-			const editor = getNearestEditorFromDOMNode(domNode);
-			if (editor && editor.isEditable()) editor.update(() => {
-				const node = $getNearestNodeFromDOMNode(domNode);
-				if ($isListItemNode(node)) {
-					domNode.focus();
-					node.toggleChecked();
-				}
-			});
-		}
-	});
-}
-function handlePointerDown(event) {
-	handleCheckItemEvent(event, () => {
-		event.preventDefault();
-	});
-}
-function getActiveCheckListItem() {
-	const activeElement = document.activeElement;
-	return isHTMLElement$1(activeElement) && activeElement.tagName === "LI" && activeElement.parentNode && activeElement.parentNode.__lexicalListType === "check" ? activeElement : null;
+function isLikelyMathContent(content) {
+	const trimmed = content.trim();
+	if (!trimmed) return false;
+	if (/\\[A-Za-z]/.test(trimmed)) return true;
+	if (/[\d!()*+,/<=>^_{|}-]/.test(trimmed)) return true;
+	if (/^[A-Za-z]$/.test(trimmed)) return true;
+	return false;
 }
-function findCheckListItemSibling(node, backward) {
-	let sibling = backward ? node.getPreviousSibling() : node.getNextSibling();
-	let parent = node;
-	while (!sibling && $isListItemNode(parent)) {
-		parent = parent.getParentOrThrow().getParent();
-		if (parent) sibling = backward ? parent.getPreviousSibling() : parent.getNextSibling();
+//#endregion
+//#region src/plugins/math/plugin/index.ts
+const MathPlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "MathPlugin";
 	}
-	while ($isListItemNode(sibling)) {
-		const firstChild = backward ? sibling.getLastChild() : sibling.getFirstChild();
-		if (!$isListNode(firstChild)) return sibling;
-		sibling = backward ? firstChild.getLastChild() : firstChild.getFirstChild();
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		this.config = config;
+		this.logger = createDebugLogger("plugin", "math");
+		kernel.registerNodes([MathInlineNode, MathBlockNode]);
+		if (config?.theme) kernel.registerThemes(config?.theme);
+		this.registerDecorator(kernel, MathInlineNode.getType(), (node, editor) => {
+			return config?.decorator ? config.decorator(node, editor) : null;
+		});
+		this.registerDecorator(kernel, MathBlockNode.getType(), (node, editor) => {
+			return config?.decorator ? config.decorator(node, editor) : null;
+		});
 	}
-	return null;
-}
-function handleArrowUpOrDown(event, editor, backward) {
-	const activeItem = getActiveCheckListItem();
-	if (activeItem) editor.update(() => {
-		const listItem = $getNearestNodeFromDOMNode(activeItem);
-		if (!$isListItemNode(listItem)) return;
-		const nextListItem = findCheckListItemSibling(listItem, backward);
-		if (nextListItem) {
-			nextListItem.selectStart();
-			const dom = editor.getElementByKey(nextListItem.__key);
-			if (dom) {
-				event.preventDefault();
-				setTimeout(() => {
-					dom.focus();
-				}, 0);
+	onInit(editor) {
+		this.register(registerMathCommand(editor));
+		this.registerMarkdown();
+		this.registerLiteXml();
+	}
+	registerLiteXml() {
+		const litexmlService = this.kernel.requireService(ILitexmlService);
+		if (!litexmlService) return;
+		litexmlService.registerXMLWriter(MathInlineNode.getType(), (node, ctx) => {
+			if (node instanceof MathInlineNode) {
+				const attributes = { code: node.getTextContent() };
+				return ctx.createXmlNode("math", attributes);
 			}
-		}
-	});
-	return false;
-}
-function registerCheckList(editor) {
-	const registrations = [
-		editor.registerCommand(INSERT_CHECK_LIST_COMMAND, () => {
-			$insertList("check");
+			return false;
+		});
+		litexmlService.registerXMLWriter(MathBlockNode.getType(), (node, ctx) => {
+			if (node instanceof MathBlockNode) {
+				const attributes = { code: node.getTextContent() };
+				return ctx.createXmlNode("mathBlock", attributes);
+			}
+			return false;
+		});
+		litexmlService.registerXMLReader("math", (xmlNode) => {
+			return INodeHelper.createElementNode(MathInlineNode.getType(), {
+				code: xmlNode.getAttribute("code") || "",
+				version: 1
+			});
+		});
+		litexmlService.registerXMLReader("mathBlock", (xmlNode) => {
+			return INodeHelper.createElementNode(MathBlockNode.getType(), {
+				code: xmlNode.getAttribute("code") || "",
+				version: 1
+			});
+		});
+	}
+	registerMarkdown() {
+		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
+		markdownService?.registerMarkdownShortCut({
+			regExp: /\$([^\s$](?:[^$]*[^\s$])?)\$\s?$/,
+			replace: (textNode, match) => {
+				const [, code] = match;
+				if (!isLikelyMathContent(code)) return;
+				const mathNode = $createMathInlineNode(code);
+				this.logger.debug("Math node inserted:", mathNode);
+				textNode.insertBefore(mathNode);
+				textNode.setTextContent("");
+				textNode.select();
+			},
+			trigger: "$",
+			type: "text-match"
+		});
+		markdownService?.registerMarkdownShortCut({
+			regExp: /^(\$\$)$/,
+			replace: (parentNode, _1, _2, isImport) => {
+				const node = $createMathBlockNode();
+				if (isImport || parentNode.getNextSibling()) parentNode.replace(node);
+				else parentNode.insertBefore(node);
+				const sel = $createNodeSelection();
+				sel.add(node.getKey());
+				$setSelection(sel);
+			},
+			trigger: "enter",
+			type: "element"
+		});
+		markdownService?.registerMarkdownWriter(MathInlineNode.getType(), (ctx, node) => {
+			ctx.appendLine(node.getTextContent());
 			return true;
-		}, COMMAND_PRIORITY_LOW),
-		editor.registerCommand(KEY_ARROW_DOWN_COMMAND, (event) => {
-			return handleArrowUpOrDown(event, editor, false);
-		}, COMMAND_PRIORITY_LOW),
-		editor.registerCommand(KEY_ARROW_UP_COMMAND, (event) => {
-			return handleArrowUpOrDown(event, editor, true);
-		}, COMMAND_PRIORITY_LOW),
-		editor.registerCommand(KEY_ARROW_LEFT_COMMAND, (event) => {
-			return editor.getEditorState().read(() => {
-				const selection = $getSelection();
-				if ($isRangeSelection(selection) && selection.isCollapsed()) {
-					const { anchor } = selection;
-					const isElement = anchor.type === "element";
-					if (isElement || anchor.offset === 0) {
-						const anchorNode = anchor.getNode();
-						const elementNode = $findMatchingParent(anchorNode, (node) => $isElementNode(node) && !node.isInline());
-						if ($isListItemNode(elementNode)) {
-							const parent = elementNode.getParent();
-							if ($isListNode(parent) && parent.getListType() === "check" && (isElement || elementNode.getFirstDescendant() === anchorNode)) {
-								const domNode = editor.getElementByKey(elementNode.__key);
-								if (domNode && document.activeElement !== domNode) {
-									domNode.focus();
-									event.preventDefault();
-									return true;
-								}
-							}
-						}
-					}
-				}
-				return false;
+		});
+		markdownService?.registerMarkdownWriter(MathBlockNode.getType(), (ctx, node) => {
+			ctx.appendLine(node.getTextContent());
+			return true;
+		});
+		markdownService?.registerMarkdownReader("inlineMath", (node) => {
+			return INodeHelper.createElementNode("math", {
+				code: node.value,
+				version: 1
 			});
-		}, COMMAND_PRIORITY_LOW)
-	];
-	if (!isHeadlessEditor$1(editor)) registrations.push(editor.registerRootListener((rootElement, prevElement) => {
-		if (rootElement !== null) {
-			rootElement.addEventListener("click", handleClick);
-			rootElement.addEventListener("pointerdown", handlePointerDown);
-		}
-		if (prevElement !== null) {
-			prevElement.removeEventListener("click", handleClick);
-			prevElement.removeEventListener("pointerdown", handlePointerDown);
-		}
-	}));
-	return mergeRegister(...registrations);
-}
-//#endregion
-//#region src/plugins/list/plugin/registry.ts
-function registerListCommands(editor, kernel, options) {
-	const { enableHotkey = true } = options || {};
-	return mergeRegister(kernel.registerHotkey(HotkeyEnum.BulletList, () => editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, void 0), {
-		enabled: enableHotkey,
-		preventDefault: true,
-		stopImmediatePropagation: true
-	}), kernel.registerHotkey(HotkeyEnum.NumberList, () => editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, 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);
+		});
+		markdownService?.registerMarkdownReader("math", (node) => {
+			return INodeHelper.createElementNode("mathBlock", {
+				code: node.value,
+				version: 1
 			});
 		});
-		event.stopImmediatePropagation();
-		event.preventDefault();
+	}
+};
+//#endregion
+//#region src/plugins/mention/node/MentionNode.ts
+var MentionNode = class MentionNode extends DecoratorNode {
+	static getType() {
+		return "mention";
+	}
+	static clone(node) {
+		return new MentionNode(node.__label, node.__metadata, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createMentionNode().updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { span: (node) => {
+			if (node.classList.contains("mention")) return {
+				conversion: $convertMentionElement,
+				priority: 0
+			};
+			return null;
+		} };
+	}
+	constructor(label = "", metadata = {}, key) {
+		super(key);
+		this.__label = label;
+		this.__metadata = metadata;
+	}
+	get label() {
+		return this.__label;
+	}
+	get metadata() {
+		return this.__metadata;
+	}
+	exportDOM() {
+		return { element: document.createElement("span") };
+	}
+	createDOM(config) {
+		const element = document.createElement("span");
+		addClassNamesToElement(element, config.theme.mention);
+		return element;
+	}
+	getTextContent() {
+		return this.label;
+	}
+	isInline() {
+		return true;
+	}
+	updateDOM() {
+		return false;
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			label: this.label,
+			metadata: this.metadata
+		};
+	}
+	updateFromJSON(serializedNode) {
+		const node = super.updateFromJSON(serializedNode);
+		this.__label = serializedNode.label || "";
+		this.__metadata = serializedNode.metadata || {};
+		return node;
+	}
+	decorate(editor) {
+		const decorator = getKernelFromEditor(editor)?.getDecorator(MentionNode.getType());
+		if (!decorator) return null;
+		if (typeof decorator === "function") return decorator(this, editor);
+		return {
+			queryDOM: decorator.queryDOM,
+			render: decorator.render(this, editor)
+		};
+	}
+};
+function $createMentionNode(label, metadata) {
+	return $applyNodeReplacement(new MentionNode(label, metadata));
+}
+function $convertMentionElement() {
+	return { node: $createMentionNode() };
+}
+function $isMentionNode(node) {
+	return node.getType() === MentionNode.getType();
+}
+//#endregion
+//#region src/plugins/mention/command/index.ts
+const INSERT_MENTION_COMMAND = createCommand("INSERT_MENTION_COMMAND");
+function registerMentionCommand(editor) {
+	return editor.registerCommand(INSERT_MENTION_COMMAND, (payload) => {
+		const { metadata, label } = payload;
+		editor.update(() => {
+			const mentionNode = $createMentionNode(label, metadata);
+			$insertNodes([mentionNode]);
+			if ($isRootOrShadowRoot(mentionNode.getParentOrThrow())) $wrapNodeInElement(mentionNode, $createParagraphNode).selectEnd();
+		});
 		return true;
-	}, COMMAND_PRIORITY_LOW));
+	}, COMMAND_PRIORITY_HIGH);
 }
 //#endregion
-//#region src/plugins/list/plugin/index.ts
-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 {
+//#region src/plugins/mention/plugin/register.ts
+function registerMentionNodeSelectionObserver(editor) {
+	const selectMentionKeys = [];
+	return editor.registerUpdateListener(({ editorState }) => {
+		const selection = editorState.read(() => $getSelection());
+		const newSelectMentionKeys = [];
+		if ($isNodeSelection(selection)) editorState.read(() => selection.getNodes()).forEach((node) => {
+			if (node.getType() === "mention") newSelectMentionKeys.push(node.getKey());
+		});
+		else if ($isRangeSelection(selection) && !selection.isCollapsed()) editorState.read(() => {
+			selection.getNodes().forEach((node) => {
+				if ($isMentionNode(node)) newSelectMentionKeys.push(node.getKey());
+			});
+		});
+		const removeKeys = selectMentionKeys.filter((key) => !newSelectMentionKeys.includes(key));
+		const addKeys = newSelectMentionKeys.filter((key) => !selectMentionKeys.includes(key));
+		selectMentionKeys.length = 0;
+		selectMentionKeys.push(...newSelectMentionKeys);
+		removeKeys.forEach((key) => {
+			editor.getElementByKey(key)?.classList.remove("selected");
+		});
+		addKeys.forEach((key) => {
+			editor.getElementByKey(key)?.classList.add("selected");
+		});
+	});
+}
+//#endregion
+//#region src/plugins/mention/plugin/index.ts
+const MentionPlugin = class extends KernelPlugin {
 	static {
-		this.pluginName = "ListPlugin";
+		this.pluginName = "MentionPlugin";
 	}
 	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)
-		} });
+		kernel.registerNodes([MentionNode]);
+		if (config?.theme) kernel.registerThemes(config?.theme);
+		this.registerDecorator(kernel, MentionNode.getType(), (node, editor) => {
+			return config?.decorator ? config.decorator(node, editor) : null;
+		});
 	}
 	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.register(registerMentionCommand(editor));
+		if (this.config?.decorator) this.register(registerMentionNodeSelectionObserver(editor));
 		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.kernel.requireService(ILitexmlService)?.registerXMLWriter(MentionNode.getType(), (node, ctx) => {
+			if ($isMentionNode(node)) {
+				const attributes = { label: node.label };
+				if (node.metadata && Object.keys(node.metadata).length > 0) attributes.metadata = JSON.stringify(node.metadata);
+				return ctx.createXmlNode("mention", 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
+		this.kernel.requireService(ILitexmlService)?.registerXMLReader("mention", (xmlNode) => {
+			return INodeHelper.createElementNode(MentionNode.getType(), {
+				label: xmlNode.getAttribute("label") || "",
+				metadata: xmlNode.getAttribute("metadata") ? JSON.parse(xmlNode.getAttribute("metadata")) : {}
 			});
 		});
 	}
 	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;
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(MentionNode.getType(), (ctx, node) => {
+			if ($isMentionNode(node)) {
+				if (this.config?.markdownWriter) {
+					ctx.appendLine(this.config.markdownWriter(node));
+					return;
 				}
+				ctx.appendLine(`${node.label}`);
 			}
 		});
-		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;
-			});
-		});
+		if (this.config?.markdownReader) this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownReader("html", (node, children) => {
+			return this.config?.markdownReader ? this.config.markdownReader(node, children) || false : false;
+		}, 1);
 	}
 };
 //#endregion
@@ -7286,85 +9255,6 @@ const TablePlugin = class extends KernelPlugin {
 	}
 };
 //#endregion
-//#region src/plugins/codeblock/utils/language.ts
-function getCodeLanguageByInput(input) {
-	if (!input) return "plaintext";
-	const inputLang = input.toLocaleLowerCase();
-	return bundledLanguagesInfo.find((lang) => lang.id === inputLang || lang.aliases?.includes(inputLang))?.id || "plaintext";
-}
-//#endregion
-//#region src/headless/plugins/codeblock.ts
-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/extract-media-from-editor-state.ts
 const IMAGE_TYPES = new Set(["image", "block-image"]);
 const FILE_TYPE = "file";
@@ -7502,10 +9392,15 @@ const preserveSerializedCodeTextInEditorData = (editorData) => ({
 });
 const DEFAULT_HEADLESS_EDITOR_PLUGINS = [
 	[CommonPlugin, { enableHotkey: false }],
+	INodePlugin,
 	MarkdownPlugin,
 	[LinkPlugin, { enableHotkey: false }],
 	CodePlugin,
-	HeadlessCodeblockPlugin,
+	CodemirrorPlugin,
+	ImagePlugin,
+	FilePlugin,
+	MathPlugin,
+	MentionPlugin,
 	HRPlugin,
 	ListPlugin,
 	TablePlugin,