@lobehub/editor 4.15.1 → 4.15.2

package/es/plugins/link/node/LinkNode.d.ts

@@ -0,0 +1,10 @@
+import { BaseSelection, DOMConversionMap, EditorConfig, ElementNode, LexicalCommand, LexicalEditor, LexicalNode, LexicalUpdateJSON, NodeKey, RangeSelection, SerializedElementNode, Spread } from "lexical";
+
+//#region src/plugins/link/node/LinkNode.d.ts
+type LinkAttributes = {
+  rel?: null | string;
+  target?: null | string;
+  title?: null | string;
+};
+//#endregion
+export { LinkAttributes };

package/es/plugins/link/node/LinkNode.js

@@ -0,0 +1,448 @@
+import { createDebugLogger, init_debug } from "../../../utils/debug.js";
+import { assert, init_utils } from "../../../editor-kernel/utils.js";
+import { $applyNodeReplacement, $getSelection, $isElementNode, $isNodeSelection, $isRangeSelection, $normalizeSelection__EXPERIMENTAL, $setSelection, ElementNode, createCommand } from "lexical";
+import { $findMatchingParent, addClassNamesToElement, isHTMLAnchorElement } from "@lexical/utils";
+//#region src/plugins/link/node/LinkNode.ts
+init_utils();
+init_debug();
+const logger = createDebugLogger("plugin", "link");
+const SUPPORTED_URL_PROTOCOLS = 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.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
+export { $createLinkNode, $isLinkNode, $toggleLink, AutoLinkNode, HOVER_LINK_COMMAND, HOVER_OUT_LINK_COMMAND, LinkNode, TOGGLE_LINK_COMMAND, formatUrl };

package/es/plugins/link/plugin/index.d.ts

@@ -0,0 +1,16 @@
+import { IEditorPluginConstructor } from "../../../types/kernel.js";
+import { LinkAttributes } from "../node/LinkNode.js";
+
+//#region src/plugins/link/plugin/index.d.ts
+interface LinkPluginOptions {
+  attributes?: LinkAttributes;
+  enableHotkey?: boolean;
+  linkRegex?: RegExp;
+  theme?: {
+    link?: string;
+  };
+  validateUrl?: (url: string) => boolean;
+}
+declare const LinkPlugin: IEditorPluginConstructor<LinkPluginOptions>;
+//#endregion
+export { LinkPlugin, LinkPluginOptions };

package/es/plugins/link/plugin/index.js

@@ -0,0 +1,106 @@
+import { INodeHelper, init_helper } from "../../../editor-kernel/inode/helper.js";
+import { KernelPlugin, init_plugin } from "../../../editor-kernel/plugin.js";
+import { ILitexmlService } from "../../litexml/service/litexml-service.js";
+import { IMarkdownShortCutService } from "../../markdown/service/shortcut.js";
+import { $createLinkNode, $isLinkNode, AutoLinkNode, LinkNode } from "../node/LinkNode.js";
+import { INSERT_LINK_COMMAND, registerLinkCommand } from "../command/index.js";
+import { ILinkService, LinkService } from "../service/i-link-service.js";
+import { registerLinkCommands } from "./registry.js";
+import { $createTextNode, COMMAND_PRIORITY_NORMAL, PASTE_COMMAND } from "lexical";
+//#region src/plugins/link/plugin/index.ts
+init_helper();
+init_plugin();
+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
+export { LinkPlugin };

package/es/plugins/link/plugin/registry.js

@@ -0,0 +1,82 @@
+import { HotkeyEnum, init_hotkey } from "../../../types/hotkey.js";
+import { $isLinkNode, $toggleLink, TOGGLE_LINK_COMMAND, formatUrl } from "../node/LinkNode.js";
+import { extractUrlFromText, getSelectedNode, sanitizeUrl } from "../utils/index.js";
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_LOW } from "lexical";
+import { mergeRegister } from "@lexical/utils";
+//#region src/plugins/link/plugin/registry.ts
+init_hotkey();
+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
+export { registerLinkCommands };

package/es/plugins/link/react/ReactLinkPlugin.d.ts

@@ -0,0 +1,7 @@
+import { ReactLinkPluginProps } from "./type.js";
+import { FC } from "react";
+
+//#region src/plugins/link/react/ReactLinkPlugin.d.ts
+declare const ReactLinkPlugin: FC<ReactLinkPluginProps>;
+//#endregion
+export { ReactLinkPlugin };