@lobehub/editor 4.9.8 → 4.10.0

package/es/headless.js

@@ -6,8 +6,8 @@ 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 } 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, isHTMLElement as isHTMLElement$1, mergeRegister } from "@lexical/utils";
-import { $setBlocksType } from "@lexical/selection";
+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 { $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";
 import { DOMParser as DOMParser$1 } from "@xmldom/xmldom";
@@ -621,7 +621,7 @@ const isHotkeyMatch = (event, hotkey) => {
 };
 //#endregion
 //#region src/utils/hotkey/registerHotkey.ts
-const logger$6 = createDebugLogger("hotkey");
+const logger$7 = createDebugLogger("hotkey");
 const registerHotkey = (hotkey, callback, options = {}) => {
 	return (e) => {
 		if (!isHotkeyMatch(e, hotkey.keys)) return false;
@@ -633,7 +633,7 @@ const registerHotkey = (hotkey, callback, options = {}) => {
 			...keys,
 			scopes: hotkey.scopes
 		});
-		logger$6.debug(`⌨️ Hotkey matched: ${hotkey.id} [${hotkey.keys}]`, hotkey);
+		logger$7.debug(`⌨️ Hotkey matched: ${hotkey.id} [${hotkey.keys}]`, hotkey);
 		return true;
 	};
 };
@@ -701,6 +701,10 @@ const noop = () => {};
 function createEmptyEditorState() {
 	return createEditor().getEditorState();
 }
+function assert(cond, message) {
+	if (cond) return;
+	throw new Error(message);
+}
 function getNodeKeyFromDOMNode(dom, editor) {
 	return dom[`__lexicalKey_${editor._key}`];
 }
@@ -1378,7 +1382,7 @@ function registerCommands(editor) {
 }
 //#endregion
 //#region src/plugins/common/node/cursor.ts
-const logger$5 = createDebugLogger("common", "cursor");
+const logger$6 = createDebugLogger("common", "cursor");
 var CardLikeElementNode = class extends ElementNode {
 	isCardLike() {
 		return true;
@@ -1417,7 +1421,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$5.debug("🎭 DecoratorNode mutated:", node?.getType(), mutation, node);
+				logger$6.debug("🎭 DecoratorNode mutated:", node?.getType(), mutation, node);
 				if (mutation === "created" && node?.isInline() && node.getNextSibling() === null) needAddCursor.push(node);
 			}
 			if (needAddCursor.length > 0) editor.update(() => {
@@ -1519,7 +1523,7 @@ function registerCursorNode(editor) {
 			$setSelection(sel);
 			return true;
 		} catch (error) {
-			logger$5.error("❌ Cursor selection error:", error);
+			logger$6.error("❌ Cursor selection error:", error);
 		}
 		else if ($isCursorNode(focusNode)) try {
 			const { key: anchorKey, offset: anchorOffset, type: anchorType } = selection.anchor;
@@ -1530,7 +1534,7 @@ function registerCursorNode(editor) {
 			$setSelection(sel);
 			return true;
 		} catch (error) {
-			logger$5.error("❌ Cursor navigation error:", error);
+			logger$6.error("❌ Cursor navigation error:", error);
 		}
 		return false;
 	}, COMMAND_PRIORITY_HIGH), editor.registerCommand(KEY_ARROW_RIGHT_COMMAND, (event) => {
@@ -1709,7 +1713,7 @@ function charToId(char) {
 }
 //#endregion
 //#region src/plugins/litexml/command/index.ts
-const logger$4 = createDebugLogger("plugin", "litexml");
+const logger$5 = createDebugLogger("plugin", "litexml");
 function toArrayXml(litexml) {
 	return Array.isArray(litexml) ? litexml : [litexml];
 }
@@ -1721,7 +1725,7 @@ function tryParseChild(child, editor) {
 			oldNode
 		};
 	} catch (error) {
-		logger$4.error("❌ Error parsing child node:", error);
+		logger$5.error("❌ Error parsing child node:", error);
 		return {
 			newNode: null,
 			oldNode: null
@@ -1834,12 +1838,12 @@ function registerLiteXMLCommand(editor, dataSource) {
 							delay: true
 						}, dataSource);
 						break;
-					default: logger$4.warn(`⚠️ Unknown action type: ${action}`);
+					default: logger$5.warn(`⚠️ Unknown action type: ${action}`);
 				}
 			});
 			return false;
 		} catch (error) {
-			logger$4.error("❌ Error processing LITEXML_MODIFY_COMMAND:", error);
+			logger$5.error("❌ Error processing LITEXML_MODIFY_COMMAND:", error);
 			return false;
 		}
 	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(LITEXML_APPLY_COMMAND, (payload) => {
@@ -1864,9 +1868,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$4.warn(`⚠️ Node with key ${child.id} not found for diffing.`);
+					else logger$5.warn(`⚠️ Node with key ${child.id} not found for diffing.`);
 				} catch (error) {
-					logger$4.error("❌ Error replacing node:", error);
+					logger$5.error("❌ Error replacing node:", error);
 				}
 			});
 		});
@@ -1890,7 +1894,7 @@ function handleModify(editor, dataSource, arrayXml, delay) {
 					} else prevNode = prevNode.insertAfter(newNode);
 					else $insertNodes([newNode]);
 				} catch (error) {
-					logger$4.error("❌ Error replacing node:", error);
+					logger$5.error("❌ Error replacing node:", error);
 				}
 			});
 		});
@@ -2027,7 +2031,7 @@ function handleInsert(editor, payload, dataSource) {
 				});
 			}
 		} catch (error) {
-			logger$4.error("❌ Error inserting node:", error);
+			logger$5.error("❌ Error inserting node:", error);
 		}
 	});
 }
@@ -2167,7 +2171,7 @@ var LitexmlService = class {
 };
 //#endregion
 //#region src/plugins/litexml/data-source/litexml-data-source.ts
-const logger$3 = createDebugLogger("plugin", "litexml");
+const logger$4 = createDebugLogger("plugin", "litexml");
 var IXmlWriterContext = class {
 	createXmlNode(tagName, attributes, textContent) {
 		return {
@@ -2195,7 +2199,7 @@ var LitexmlDataSource = class extends DataSource {
 		const xml = this.parseXMLString(litexml);
 		const inode = this.xmlToLexical(xml);
 		this.getService?.(INodeService)?.processNodeTree(inode);
-		logger$3.debug("Parsed XML to Lexical State:", inode);
+		logger$4.debug("Parsed XML to Lexical State:", inode);
 		return inode;
 	}
 	/**
@@ -2216,7 +2220,7 @@ var LitexmlDataSource = class extends DataSource {
 			});
 			editor.setEditorState(newState);
 		} catch (error) {
-			logger$3.error("Failed to parse XML:", error);
+			logger$4.error("Failed to parse XML:", error);
 			throw error;
 		}
 	}
@@ -2251,7 +2255,7 @@ var LitexmlDataSource = class extends DataSource {
 				return this.lexicalToXML(rootNode);
 			});
 		} catch (error) {
-			logger$3.error("Failed to export to XML:", error);
+			logger$4.error("Failed to export to XML:", error);
 			throw error;
 		}
 	}
@@ -22546,7 +22550,7 @@ function remarkMath(options) {
 }
 //#endregion
 //#region src/plugins/markdown/utils/logger.ts
-const logger$2 = createDebugLogger("plugin", "markdown");
+const logger$3 = createDebugLogger("plugin", "markdown");
 //#endregion
 //#region src/plugins/markdown/data-source/markdown/parse.ts
 const selfClosingHtmlTags = new Set([
@@ -22566,8 +22570,9 @@ const selfClosingHtmlTags = new Set([
 	"wbr"
 ]);
 var MarkdownContext = class {
-	constructor(root) {
+	constructor(root, markdown) {
 		this.root = root;
+		this.markdown = markdown;
 		this.stack = [];
 	}
 	push(html) {
@@ -22583,15 +22588,36 @@ var MarkdownContext = class {
 		return this.stack.pop();
 	}
 };
-function convertMdastToLexical(node, index, ctx, markdownReaders = {}) {
+const getNodeRawMarkdown = (node, markdown) => {
+	const start = node.position?.start.offset;
+	const end = node.position?.end.offset;
+	if (typeof start === "number" && typeof end === "number") return markdown.slice(start, end);
+	if ("value" in node && typeof node.value === "string") return node.value;
+	return "";
+};
+const createFallbackRawNode = (node, ctx, parentType) => {
+	const raw = getNodeRawMarkdown(node, ctx.markdown);
+	if (!raw) return null;
+	if (parentType === null || parentType === "root") return {
+		...INodeHelper.createParagraph(),
+		children: [INodeHelper.createTextNode(raw)]
+	};
+	return INodeHelper.createTextNode(raw);
+};
+function convertMdastToLexical(node, index, ctx, markdownReaders = {}, parentType = null) {
 	switch (node.type) {
 		case "text": return INodeHelper.createTextNode(node.value);
 		default: {
+			if (!markdownReaders[node.type]) return createFallbackRawNode(node, ctx, parentType);
 			let children = [];
 			if ("children" in node && Array.isArray(node.children)) {
 				let htmlStack = [];
 				children = node.children.reduce((ret, child, index) => {
 					if (child.type === "html") {
+						if (!markdownReaders["html"]) {
+							ret.push(INodeHelper.createTextNode(child.value));
+							return ret;
+						}
 						if (child.value.startsWith("<!--") && child.value.endsWith("-->")) return ret;
 						const tag = child.value.replaceAll(/^<\/?|>$/g, "");
 						const isEndTag = child.value.startsWith("</");
@@ -22617,7 +22643,7 @@ function convertMdastToLexical(node, index, ctx, markdownReaders = {}) {
 							const top = ctx.pop();
 							htmlStack.pop();
 							if (top?.tag !== tag) {
-								logger$2.warn("HTML tag mismatch:", tag);
+								logger$3.warn("HTML tag mismatch:", tag);
 								ret.push(...top?.children || []);
 								return ret;
 							}
@@ -22653,10 +22679,10 @@ function convertMdastToLexical(node, index, ctx, markdownReaders = {}) {
 					}
 					if (htmlStack.length > 0) {
 						const top = ctx.last;
-						if (top) top.children.push(convertMdastToLexical(child, index, ctx, markdownReaders));
+						if (top) top.children.push(convertMdastToLexical(child, index, ctx, markdownReaders, node.type));
 						return ret;
 					}
-					ret.push(convertMdastToLexical(child, index, ctx, markdownReaders));
+					ret.push(convertMdastToLexical(child, index, ctx, markdownReaders, node.type));
 					return ret;
 				}, []).filter(Boolean).flat();
 				while (htmlStack.length > 0) {
@@ -22707,8 +22733,8 @@ function registerDefaultReaders(markdownReaders) {
 }
 function parseMarkdownToLexical(markdown, markdownReaders = {}) {
 	const ast = remark().use(remarkCjkFriendly).use(remarkMath).use([[remarkGfm, { singleTilde: false }]]).parse(markdown);
-	logger$2.debug("Parsed MDAST:", ast);
-	const ctx = new MarkdownContext(ast);
+	logger$3.debug("Parsed MDAST:", ast);
+	const ctx = new MarkdownContext(ast, markdown);
 	registerDefaultReaders(markdownReaders);
 	return convertMdastToLexical(ast, 0, ctx, markdownReaders);
 }
@@ -22855,7 +22881,7 @@ function insertIRootNode(editor, root, selection) {
 }
 //#endregion
 //#region src/plugins/markdown/command/index.ts
-const logger$1 = createDebugLogger("plugin", "markdown");
+const logger$2 = 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) {
@@ -22869,7 +22895,7 @@ const getLineNumber = (content, charIndex) => {
 function registerMarkdownCommand(editor, kernel, service) {
 	return mergeRegister(editor.registerCommand(INSERT_MARKDOWN_COMMAND, (payload) => {
 		const { markdown } = payload;
-		logger$1.debug("INSERT_MARKDOWN_COMMAND payload:", payload);
+		logger$2.debug("INSERT_MARKDOWN_COMMAND payload:", payload);
 		restoreToEntry(editor, payload.historyState);
 		setTimeout(() => {
 			editor.update(() => {
@@ -22877,11 +22903,11 @@ function registerMarkdownCommand(editor, kernel, service) {
 					const root = parseMarkdownToLexical(markdown, service.markdownReaders);
 					const selection = $getSelection();
 					const nodes = $generateNodesFromSerializedNodes(root.children);
-					logger$1.debug("INSERT_MARKDOWN_COMMAND nodes:", nodes);
+					logger$2.debug("INSERT_MARKDOWN_COMMAND nodes:", nodes);
 					$insertGeneratedNodes(editor, nodes, selection);
 					return true;
 				} catch (error) {
-					logger$1.error("Failed to handle markdown paste:", error);
+					logger$2.error("Failed to handle markdown paste:", error);
 				}
 			}, { tag: HISTORY_PUSH_TAG });
 		}, 0);
@@ -22912,8 +22938,8 @@ function registerMarkdownCommand(editor, kernel, service) {
 				const startLine = getLineNumber(markdownContent, startIndex);
 				const endLine = getLineNumber(markdownContent, endIndex);
 				payload.onResult(startLine, endLine);
-				logger$1.debug("GET_MARKDOWN_SELECTION_COMMAND markdownContent:", markdownContent);
-				logger$1.debug("GET_MARKDOWN_SELECTION_COMMAND startLine:", startLine, "endLine:", endLine);
+				logger$2.debug("GET_MARKDOWN_SELECTION_COMMAND markdownContent:", markdownContent);
+				logger$2.debug("GET_MARKDOWN_SELECTION_COMMAND startLine:", startLine, "endLine:", endLine);
 				return markdownContent;
 			} });
 		}
@@ -22973,7 +22999,7 @@ var MarkdownDataSource = class extends DataSource {
 			}).processSync(markdown);
 			return String(result);
 		} catch (error) {
-			logger$2.error("Failed to format markdown:", error);
+			logger$3.error("Failed to format markdown:", error);
 			return markdown;
 		}
 	}
@@ -22986,7 +23012,7 @@ var MarkdownDataSource = class extends DataSource {
 	read(editor, data) {
 		const inode = { root: parseMarkdownToLexical(data, this.markdownService.markdownReaders) };
 		this.getService?.(INodeService)?.processNodeTree(inode);
-		logger$2.debug("Parsed Lexical State:", inode);
+		logger$3.debug("Parsed Lexical State:", inode);
 		editor.setEditorState(editor.parseEditorState(inode));
 	}
 	write(editor, options) {
@@ -24401,7 +24427,7 @@ function runPasteHandlers(ctx, handlers) {
 }
 //#endregion
 //#region src/plugins/common/plugin/register.ts
-const logger = createDebugLogger("plugin", "common");
+const logger$1 = createDebugLogger("plugin", "common");
 function resolveElement(element, isBackward, focusOffset) {
 	const parent = element.getParent();
 	let offset = focusOffset;
@@ -24502,7 +24528,7 @@ function registerRichKeydown(editor, kernel, options) {
 				selection.insertText(text);
 			});
 		} catch (error) {
-			logger.error("❌ Failed to paste as plain text:", error);
+			logger$1.error("❌ Failed to paste as plain text:", error);
 		}
 	}, {
 		enabled: enableHotkey,
@@ -24760,7 +24786,7 @@ const CommonPlugin = class extends KernelPlugin {
 		const breakMark = (this.config?.markdownOption ?? true) !== false ? "\n\n" : "\n";
 		const formats = this.formats;
 		if (formats.quote) markdownService.registerMarkdownShortCut({
-			regExp: /^>\s/,
+			regExp: /^(>|》)\s/,
 			replace: (parentNode, children, _match, isImport) => {
 				if (isImport) {
 					const previousNode = parentNode.getPreviousSibling();
@@ -25307,6 +25333,701 @@ const HRPlugin = class extends KernelPlugin {
 	}
 };
 //#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", {
+				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
@@ -26113,6 +26834,7 @@ const normalizeLegacyEditorData = (editorData) => {
 const DEFAULT_HEADLESS_EDITOR_PLUGINS = [
 	[CommonPlugin, { enableHotkey: false }],
 	MarkdownPlugin,
+	[LinkPlugin, { enableHotkey: false }],
 	CodePlugin,
 	HeadlessCodeblockPlugin,
 	HRPlugin,