@lobehub/editor 1.19.0 → 1.20.0

package/es/index.d.ts

@@ -7,6 +7,7 @@ export * from './plugins/file';
 export * from './plugins/hr';
 export * from './plugins/image';
 export * from './plugins/link';
+export * from './plugins/link-highlight';
 export * from './plugins/list';
 export * from './plugins/markdown';
 export * from './plugins/math';
@@ -17,6 +18,7 @@ export * from './plugins/upload';
 export type { IEditor } from './types';
 export * from './types/hotkey';
 export { getHotkeyById } from './utils/hotkey/registerHotkey';
+export { isPureUrl, isValidUrl } from './utils/url';
 export { browserDebug, createDebugLogger, debugLogger, debugLoggers, devConsole, prodSafeLogger, } from './utils/debug';
 export { Kernel } from './editor-kernel/kernel';
 /**

package/es/index.js

@@ -7,6 +7,7 @@ export * from "./plugins/file";
 export * from "./plugins/hr";
 export * from "./plugins/image";
 export * from "./plugins/link";
+export * from "./plugins/link-highlight";
 export * from "./plugins/list";
 export * from "./plugins/markdown";
 export * from "./plugins/math";
@@ -18,6 +19,9 @@ export * from "./plugins/upload";
 export * from "./types/hotkey";
 export { getHotkeyById } from "./utils/hotkey/registerHotkey";
 
+// URL utilities
+export { isPureUrl, isValidUrl } from "./utils/url";
+
 // Debug utilities
 export { browserDebug, createDebugLogger, debugLogger, debugLoggers, devConsole, prodSafeLogger } from "./utils/debug";
 

package/es/plugins/code/node/code.d.ts

@@ -1,5 +1,5 @@
 import { EditorConfig, LexicalEditor, LexicalNode, SerializedElementNode } from 'lexical';
-import { CardLikeElementNode } from "../../common";
+import { CardLikeElementNode } from "../../common/node/cursor";
 export type SerializedCodeNode = SerializedElementNode;
 export declare class CodeNode extends CardLikeElementNode {
     static getType(): string;

package/es/plugins/code/node/code.js

@@ -16,7 +16,7 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import { addClassNamesToElement } from '@lexical/utils';
 import { $applyNodeReplacement, $createTextNode, $getSelection, $isNodeSelection, $isRangeSelection } from 'lexical';
-import { $createCursorNode, $isCursorNode, CardLikeElementNode } from "../../common";
+import { $createCursorNode, $isCursorNode, CardLikeElementNode } from "../../common/node/cursor";
 export var CodeNode = /*#__PURE__*/function (_CardLikeElementNode) {
   _inherits(CodeNode, _CardLikeElementNode);
   var _super = _createSuper(CodeNode);

package/es/plugins/code/react/CodeReactPlugin.js

@@ -8,7 +8,7 @@ function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" !=
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 import { useLayoutEffect } from 'react';
 import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context";
-import { MarkdownPlugin } from "../../markdown";
+import { MarkdownPlugin } from "../../markdown/plugin";
 import { CodePlugin } from "../plugin";
 import { useStyles } from "./style";
 var ReactCodePlugin = function ReactCodePlugin(_ref) {

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

@@ -17,7 +17,7 @@ import { $createCodeNode, $isCodeHighlightNode, $isCodeNode, CodeHighlightNode,
 import { TabNode } from 'lexical';
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
-import { IMarkdownShortCutService } from "../../markdown";
+import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { CustomShikiTokenizer, registerCodeCommand } from "../command";
 import { getCodeLanguageByInput } from "../utils/language";
 import { registerCodeHighlighting, toCodeTheme } from "./CodeHighlighterShiki";

package/es/plugins/codeblock/react/ReactCodeblockPlugin.js

@@ -9,7 +9,7 @@ function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 import { usePrevious } from 'ahooks';
 import { useEffect, useLayoutEffect, useRef } from 'react';
 import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context";
-import { MarkdownPlugin } from "../../markdown";
+import { MarkdownPlugin } from "../../markdown/plugin";
 import { CodeblockPlugin } from "../plugin";
 import { colorReplacements, useStyles } from "./style";
 export var ReactCodeblockPlugin = function ReactCodeblockPlugin(_ref) {

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

@@ -26,7 +26,8 @@ import { createEmptyHistoryState, registerHistory } from '@lexical/history';
 import { $createHeadingNode, $createQuoteNode, $isHeadingNode, $isQuoteNode, HeadingNode, QuoteNode, registerRichText } from '@lexical/rich-text';
 import { $createLineBreakNode, $createParagraphNode, $getSelection, $isRangeSelection, $isTextNode, COMMAND_PRIORITY_HIGH, INSERT_LINE_BREAK_COMMAND, INSERT_PARAGRAPH_COMMAND } from 'lexical';
 import { KernelPlugin } from "../../../editor-kernel/plugin";
-import { IMarkdownShortCutService, isPunctuationChar } from "../../markdown";
+import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
+import { isPunctuationChar } from "../../markdown/utils";
 import { registerCommands } from "../command";
 import JSONDataSource from "../data-source/json-data-source";
 import TextDataSource from "../data-source/text-data-source";

package/es/plugins/common/plugin/mdReader.d.ts

@@ -1,2 +1,2 @@
-import type { IMarkdownShortCutService } from "../../markdown";
+import type { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 export declare function registerMDReader(markdownService: IMarkdownShortCutService): void;

package/es/plugins/common/react/ReactPlainText.js

@@ -20,7 +20,7 @@ import { Children, memo, useEffect, useLayoutEffect, useRef, useState } from 're
 import { LexicalErrorBoundary } from "../../../editor-kernel/react/LexicalErrorBoundary";
 import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context";
 import { useDecorators } from "../../../editor-kernel/react/useDecorators";
-import { MarkdownPlugin } from "../../markdown";
+import { MarkdownPlugin } from "../../markdown/plugin";
 import { CommonPlugin } from "../plugin";
 import Placeholder from "./Placeholder";
 import { useStyles, useThemeStyles } from "./style";

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

@@ -19,7 +19,7 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
 import { $wrapNodeInElement } from '@lexical/utils';
 import { $createParagraphNode, $createRangeSelection, $insertNodes, $isRootOrShadowRoot, $setSelection } from 'lexical';
 import { KernelPlugin } from "../../../editor-kernel/plugin";
-import { IMarkdownShortCutService } from "../../markdown";
+import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { IUploadService } from "../../upload";
 import { createDebugLogger } from "../../../utils/debug";
 import { registerFileCommand } from "../command";

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

@@ -15,7 +15,7 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
-import { IMarkdownShortCutService } from "../../markdown";
+import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { registerHorizontalRuleCommand } from "../command";
 import { $createHorizontalRuleNode, $isHorizontalRuleNode, HorizontalRuleNode } from "../node/HorizontalRuleNode";
 

package/es/plugins/hr/react/ReactHRPlugin.js

@@ -8,7 +8,7 @@ function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" !=
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 import { useLayoutEffect } from 'react';
 import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context";
-import { MarkdownPlugin } from "../../markdown";
+import { MarkdownPlugin } from "../../markdown/plugin";
 import { HRPlugin } from "../plugin";
 import HRNode from "./components/HRNode";
 import { jsx as _jsx } from "react/jsx-runtime";

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

@@ -22,7 +22,7 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
 import { $createTextNode, COMMAND_PRIORITY_NORMAL, PASTE_COMMAND } from 'lexical';
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
-import { IMarkdownShortCutService } from "../../markdown";
+import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { INSERT_LINK_COMMAND, registerLinkCommand } from "../command";
 import { $createLinkNode, $isLinkNode, AutoLinkNode, LinkNode } from "../node/LinkNode";
 import { registerLinkCommands } from "./registry";

package/es/plugins/link/react/ReactLinkPlugin.js

@@ -9,7 +9,7 @@ function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 import { useLayoutEffect } from 'react';
 import PortalAnchor from "../../../editor-kernel/react/PortalAnchor";
 import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context";
-import { MarkdownPlugin } from "../../markdown";
+import { MarkdownPlugin } from "../../markdown/plugin";
 import { LinkPlugin } from "../plugin";
 import LinkEdit from "./components/LinkEdit";
 import LinkToolbar from "./components/LinkToolbar";

package/es/plugins/link-highlight/command/index.d.ts

@@ -0,0 +1,3 @@
+import { LexicalEditor } from 'lexical';
+export declare const INSERT_LINK_HIGHLIGHT_COMMAND: import("lexical").LexicalCommand<undefined>;
+export declare function registerLinkHighlightCommand(editor: LexicalEditor): () => void;

package/es/plugins/link-highlight/command/index.js

@@ -0,0 +1,46 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import { $getSelection, $insertNodes, $isRangeSelection, COMMAND_PRIORITY_EDITOR, createCommand } from 'lexical';
+import { $createCursorNode } from "../../common/node/cursor";
+import { $createLinkHighlightNode, $isLinkHighlightNode, getLinkHighlightNode } from "../node/link-highlight";
+export var INSERT_LINK_HIGHLIGHT_COMMAND = createCommand('INSERT_LINK_HIGHLIGHT_COMMAND');
+export function registerLinkHighlightCommand(editor) {
+  return editor.registerCommand(INSERT_LINK_HIGHLIGHT_COMMAND, function () {
+    editor.update(function () {
+      var selection = $getSelection();
+      if (!selection || !$isRangeSelection(selection)) {
+        return false;
+      }
+      var focusNode = selection.focus.getNode();
+      var anchorNode = selection.anchor.getNode();
+      var linkHighlight = getLinkHighlightNode(focusNode);
+      if (linkHighlight !== getLinkHighlightNode(anchorNode)) {
+        return false;
+      }
+      if ($isLinkHighlightNode(linkHighlight)) {
+        // Remove link highlight formatting
+        var _iterator = _createForOfIteratorHelper(linkHighlight.getChildren().slice(0)),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var node = _step.value;
+            linkHighlight.insertBefore(node);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        linkHighlight.remove();
+        return true;
+      }
+
+      // Create link highlight with selected text
+      var linkHighlightNode = $createLinkHighlightNode(selection.getTextContent());
+      $insertNodes([linkHighlightNode, $createCursorNode()]);
+      linkHighlightNode.select();
+    });
+    return true;
+  }, COMMAND_PRIORITY_EDITOR);
+}

package/es/plugins/link-highlight/index.d.ts

@@ -0,0 +1,4 @@
+export * from './command';
+export * from './node/link-highlight';
+export * from './plugin';
+export * from './react';

package/es/plugins/link-highlight/index.js

@@ -0,0 +1,5 @@
+export * from "./command";
+export * from "./node/link-highlight";
+export * from "./plugin";
+export * from "./react";
+// Note: utils are internal only and not exported to avoid conflicts with other plugins

package/es/plugins/link-highlight/node/link-highlight.d.ts

@@ -0,0 +1,29 @@
+import { EditorConfig, LexicalEditor, LexicalNode, SerializedElementNode } from 'lexical';
+import { CardLikeElementNode } from "../../common/node/cursor";
+export type SerializedLinkHighlightNode = SerializedElementNode;
+export declare class LinkHighlightNode extends CardLikeElementNode {
+    static getType(): string;
+    static clone(node: LinkHighlightNode): LinkHighlightNode;
+    static importJSON(serializedNode: SerializedLinkHighlightNode): LinkHighlightNode;
+    createDOM(config: EditorConfig, editor: LexicalEditor): HTMLElement;
+    /**
+     * Format URL to ensure it has proper protocol
+     */
+    private formatUrl;
+    getDOMSlot(element: HTMLElement): import("lexical").ElementDOMSlot<HTMLElement>;
+    canBeEmpty(): boolean;
+    isCardLike(): boolean;
+    isInline(): boolean;
+    canIndent(): boolean;
+    canInsertTextBefore(): boolean;
+    canInsertTextAfter(): boolean;
+    updateDOM(prevNode: LinkHighlightNode, dom: HTMLElement, config: EditorConfig): boolean;
+    /**
+     * Get the URL from the text content
+     */
+    getURL(): string;
+}
+export declare function $createLinkHighlightNode(textContent?: string): LinkHighlightNode;
+export declare function $isLinkHighlightNode(node: unknown): node is LinkHighlightNode;
+export declare function getLinkHighlightNode(node: LexicalNode): LexicalNode | null;
+export declare function $isSelectionInLinkHighlight(editor: LexicalEditor): boolean;

package/es/plugins/link-highlight/node/link-highlight.js

@@ -0,0 +1,223 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+/* eslint-disable @typescript-eslint/no-use-before-define */
+import { addClassNamesToElement } from '@lexical/utils';
+import { $applyNodeReplacement, $createTextNode, $getSelection, $isNodeSelection, $isRangeSelection } from 'lexical';
+import { $createCursorNode, $isCursorNode, CardLikeElementNode } from "../../common/node/cursor";
+export var LinkHighlightNode = /*#__PURE__*/function (_CardLikeElementNode) {
+  _inherits(LinkHighlightNode, _CardLikeElementNode);
+  var _super = _createSuper(LinkHighlightNode);
+  function LinkHighlightNode() {
+    _classCallCheck(this, LinkHighlightNode);
+    return _super.apply(this, arguments);
+  }
+  _createClass(LinkHighlightNode, [{
+    key: "createDOM",
+    value: function createDOM(config, editor) {
+      var _this = this;
+      var element = document.createElement('span');
+      // eslint-disable-next-line unicorn/prefer-dom-node-dataset
+      element.setAttribute('data-lexical-key', this.getKey());
+      var childContainer = document.createElement('ne-content');
+      element.append(childContainer);
+      addClassNamesToElement(element, config.theme.linkHighlight);
+
+      // Add click handler to open link in new window
+      element.addEventListener('click', function (event) {
+        // Only handle left click without modifier keys
+        if (event.button === 0 && !event.metaKey && !event.ctrlKey && !event.shiftKey) {
+          event.preventDefault();
+          event.stopPropagation();
+
+          // Read URL in editor context
+          editor.read(function () {
+            var url = _this.getURL();
+            if (url) {
+              // Format URL to ensure it has proper protocol
+              var formattedUrl = _this.formatUrl(url);
+              window.open(formattedUrl, '_blank', 'noopener,noreferrer');
+            }
+          });
+        }
+      });
+      return element;
+    }
+
+    /**
+     * Format URL to ensure it has proper protocol
+     */
+  }, {
+    key: "formatUrl",
+    value: function formatUrl(url) {
+      // Check if URL already has a protocol
+      if (/^[a-z][\d+.a-z-]*:/i.test(url)) {
+        return url;
+      }
+      // Check if it's a relative path
+      if (/^[#./]/.test(url)) {
+        return url;
+      }
+      // Check for email address
+      if (url.includes('@') && !url.startsWith('mailto:')) {
+        return "mailto:".concat(url);
+      }
+      // Check for phone number
+      if (/^\+?[\d\s()-]{5,}$/.test(url)) {
+        return "tel:".concat(url);
+      }
+      // Default to https
+      if (url.startsWith('www.')) {
+        return "https://".concat(url);
+      }
+      // If no protocol, assume https
+      if (!url.includes('://')) {
+        return "https://".concat(url);
+      }
+      return url;
+    }
+  }, {
+    key: "getDOMSlot",
+    value: function getDOMSlot(element) {
+      var neContent = element.querySelector('ne-content');
+      if (!neContent) {
+        throw new Error('LinkHighlightNode: ne-content not found');
+      }
+      return _get(_getPrototypeOf(LinkHighlightNode.prototype), "getDOMSlot", this).call(this, element).withElement(neContent);
+    }
+  }, {
+    key: "canBeEmpty",
+    value: function canBeEmpty() {
+      return false;
+    }
+  }, {
+    key: "isCardLike",
+    value: function isCardLike() {
+      return true;
+    }
+  }, {
+    key: "isInline",
+    value: function isInline() {
+      return true;
+    }
+  }, {
+    key: "canIndent",
+    value: function canIndent() {
+      return false;
+    }
+  }, {
+    key: "canInsertTextBefore",
+    value: function canInsertTextBefore() {
+      return true;
+    }
+  }, {
+    key: "canInsertTextAfter",
+    value: function canInsertTextAfter() {
+      return true;
+    }
+  }, {
+    key: "updateDOM",
+    value: function updateDOM(prevNode, dom, config) {
+      // Update the class names if theme has changed
+      var prevTheme = prevNode ? prevNode : null;
+      if (prevTheme !== this) {
+        addClassNamesToElement(dom, config.theme.linkHighlight);
+      }
+      return false;
+    }
+
+    /**
+     * Get the URL from the text content
+     */
+  }, {
+    key: "getURL",
+    value: function getURL() {
+      return this.getTextContent().trim();
+    }
+  }], [{
+    key: "getType",
+    value: function getType() {
+      return 'linkHighlight';
+    }
+  }, {
+    key: "clone",
+    value: function clone(node) {
+      return new LinkHighlightNode(node.__key);
+    }
+  }, {
+    key: "importJSON",
+    value: function importJSON(serializedNode) {
+      return $createLinkHighlightNode().updateFromJSON(serializedNode);
+    }
+  }]);
+  return LinkHighlightNode;
+}(CardLikeElementNode);
+export function $createLinkHighlightNode(textContent) {
+  var linkHighlightNode = $applyNodeReplacement(new LinkHighlightNode());
+  var cursorNode = $createCursorNode();
+  linkHighlightNode.append(cursorNode);
+  if (textContent) {
+    linkHighlightNode.append($createTextNode(textContent));
+  }
+  return linkHighlightNode;
+}
+export function $isLinkHighlightNode(node) {
+  return node instanceof LinkHighlightNode;
+}
+export function getLinkHighlightNode(node) {
+  if ($isCursorNode(node)) {
+    var parent = node.getParent();
+    if ($isLinkHighlightNode(parent)) {
+      return parent;
+    }
+    if ($isLinkHighlightNode(node.getNextSibling())) {
+      return node.getNextSibling();
+    }
+    if ($isLinkHighlightNode(node.getPreviousSibling())) {
+      return node.getPreviousSibling();
+    }
+    return null;
+  }
+  if ($isLinkHighlightNode(node.getParent())) {
+    return node.getParent();
+  }
+  return null;
+}
+export function $isSelectionInLinkHighlight(editor) {
+  return editor.read(function () {
+    var selection = $getSelection();
+    if (!selection) {
+      return false;
+    }
+    if ($isRangeSelection(selection)) {
+      var focusNode = selection.focus.getNode();
+      var anchorNode = selection.anchor.getNode();
+      var linkHighlight = getLinkHighlightNode(focusNode);
+      if (linkHighlight !== getLinkHighlightNode(anchorNode)) {
+        return false;
+      }
+      if ($isLinkHighlightNode(linkHighlight)) {
+        return true;
+      }
+      return false;
+    } else if ($isNodeSelection(selection)) {
+      var nodes = selection.getNodes();
+      if (nodes.length === 1 && $isLinkHighlightNode(nodes[0])) {
+        return true;
+      }
+    }
+    return false;
+  });
+}

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

@@ -0,0 +1,15 @@
+import type { IEditorPluginConstructor } from "../../../types";
+export interface LinkHighlightPluginOptions {
+    enableHotkey?: boolean;
+    /**
+     * Enable auto-highlight when pasting URLs
+     * @default true
+     */
+    enablePasteAutoHighlight?: boolean;
+    theme?: string;
+    /**
+     * Custom URL validation regex
+     */
+    urlRegex?: RegExp;
+}
+export declare const LinkHighlightPlugin: IEditorPluginConstructor<LinkHighlightPluginOptions>;