@lobehub/editor 1.16.3 → 1.17.1

package/es/index.d.ts

@@ -8,6 +8,7 @@ export * from './plugins/hr';
 export * from './plugins/image';
 export * from './plugins/link';
 export * from './plugins/list';
+export * from './plugins/markdown';
 export * from './plugins/math';
 export * from './plugins/mention';
 export * from './plugins/slash';

package/es/index.js

@@ -8,6 +8,7 @@ export * from "./plugins/hr";
 export * from "./plugins/image";
 export * from "./plugins/link";
 export * from "./plugins/list";
+export * from "./plugins/markdown";
 export * from "./plugins/math";
 export * from "./plugins/mention";
 export * from "./plugins/slash";

package/es/locale/index.d.ts

@@ -16,6 +16,12 @@ declare const _default: {
         placeholder: string;
         unlink: string;
     };
+    markdown: {
+        cancel: string;
+        confirm: string;
+        parseMessage: string;
+        parseTitle: string;
+    };
     math: {
         placeholder: string;
     };

package/es/locale/index.js

@@ -16,6 +16,12 @@ export default {
     placeholder: 'Enter link URL',
     unlink: 'Unlink Link'
   },
+  markdown: {
+    cancel: 'Cancel',
+    confirm: 'Confirm',
+    parseMessage: 'Convert to markdown format, existing content will be overwritten, confirm? (Auto close in 5 seconds)',
+    parseTitle: 'Parse Markdown'
+  },
   math: {
     placeholder: 'Enter TeX formula'
   },

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

@@ -24,7 +24,7 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
 import { registerDragonSupport } from '@lexical/dragon';
 import { createEmptyHistoryState, registerHistory } from '@lexical/history';
 import { $createHeadingNode, $createQuoteNode, $isHeadingNode, $isQuoteNode, HeadingNode, QuoteNode, registerRichText } from '@lexical/rich-text';
-import { $createLineBreakNode, $createParagraphNode, $isTextNode } from 'lexical';
+import { $createLineBreakNode, $createParagraphNode, $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 { registerCommands } from "../command";
@@ -82,7 +82,7 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       // Parse markdown options
       var markdownOption = (_this$config$markdown = (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.markdownOption) !== null && _this$config$markdown !== void 0 ? _this$config$markdown : true;
       var isMarkdownEnabled = markdownOption !== false;
-      var softBreak = isMarkdownEnabled ? '\n\n' : '\n';
+      var breakMark = isMarkdownEnabled ? '\n\n' : '\n';
 
       // Determine which formats are enabled
       var formats = {
@@ -189,11 +189,11 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         markdownService.registerMarkdownShortCuts(textFormatShortcuts);
       }
       markdownService.registerMarkdownWriter('paragraph', function (ctx) {
-        ctx.wrap('', softBreak);
+        ctx.wrap('', '\n');
       });
       markdownService.registerMarkdownWriter('quote', function (ctx, node) {
         if ($isQuoteNode(node)) {
-          ctx.wrap('> ', softBreak);
+          ctx.wrap('> ', breakMark);
         }
       });
       markdownService.registerMarkdownWriter('heading', function (ctx, node) {
@@ -201,37 +201,37 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
           switch (node.getTag()) {
             case 'h1':
               {
-                ctx.wrap('# ', '\n');
+                ctx.wrap('# ', breakMark);
                 break;
               }
             case 'h2':
               {
-                ctx.wrap('## ', '\n');
+                ctx.wrap('## ', breakMark);
                 break;
               }
             case 'h3':
               {
-                ctx.wrap('### ', '\n');
+                ctx.wrap('### ', breakMark);
                 break;
               }
             case 'h4':
               {
-                ctx.wrap('#### ', '\n');
+                ctx.wrap('#### ', breakMark);
                 break;
               }
             case 'h5':
               {
-                ctx.wrap('##### ', '\n');
+                ctx.wrap('##### ', breakMark);
                 break;
               }
             case 'h6':
               {
-                ctx.wrap('###### ', '\n');
+                ctx.wrap('###### ', breakMark);
                 break;
               }
             default:
               {
-                ctx.wrap('', softBreak);
+                ctx.wrap('', '\n');
                 break;
               }
           }
@@ -315,7 +315,14 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       var _this$config2;
       this.registerClears(registerRichText(editor), registerDragonSupport(editor), registerHistory(editor, createEmptyHistoryState(), 300), registerHeaderBackspace(editor), registerRichKeydown(editor, this.kernel, {
         enableHotkey: (_this$config2 = this.config) === null || _this$config2 === void 0 ? void 0 : _this$config2.enableHotkey
-      }), registerCommands(editor), registerBreakLineClick(editor), registerCursorNode(editor), registerLastElement(editor));
+      }), registerCommands(editor), registerBreakLineClick(editor), registerCursorNode(editor), registerLastElement(editor),
+      // Convert soft line breaks (Shift+Enter) to hard line breaks (paragraph breaks)
+      // This allows breaking out of code blocks with Shift+Enter
+      editor.registerCommand(INSERT_LINE_BREAK_COMMAND, function () {
+        // Dispatch paragraph command instead of line break
+        editor.dispatchCommand(INSERT_PARAGRAPH_COMMAND, undefined);
+        return true; // Prevent default line break behavior
+      }, COMMAND_PRIORITY_HIGH));
       this.registerMarkdown(this.kernel);
     }
   }, {

package/es/plugins/markdown/command/index.d.ts

@@ -0,0 +1,6 @@
+import { LexicalEditor } from 'lexical';
+import { MarkdownShortCutService } from '../service/shortcut';
+export declare const INSERT_MARKDOWN_COMMAND: import("lexical").LexicalCommand<{
+    markdown: string;
+}>;
+export declare function registerMarkdownCommand(editor: LexicalEditor, service: MarkdownShortCutService): () => void;

package/es/plugins/markdown/command/index.js

@@ -0,0 +1,27 @@
+import { $getSelection, COMMAND_PRIORITY_HIGH, createCommand } from 'lexical';
+import { createDebugLogger } from "../../../utils/debug";
+import { parseMarkdownToLexical } from "../data-source/markdown/parse";
+import { $generateNodesFromSerializedNodes, $insertGeneratedNodes } from "../utils";
+var logger = createDebugLogger('plugin', 'markdown');
+export var INSERT_MARKDOWN_COMMAND = createCommand('INSERT_MARKDOWN_COMMAND');
+export function registerMarkdownCommand(editor, service) {
+  return editor.registerCommand(INSERT_MARKDOWN_COMMAND, function (payload) {
+    var markdown = payload.markdown;
+    logger.debug('INSERT_MARKDOWN_COMMAND payload:', payload);
+    editor.update(function () {
+      try {
+        // Use the markdown data source to parse the content
+        var root = parseMarkdownToLexical(markdown, service.markdownReaders);
+        var selection = $getSelection();
+        var nodes = $generateNodesFromSerializedNodes(root.children);
+        logger.debug('INSERT_MARKDOWN_COMMAND nodes:', nodes);
+        $insertGeneratedNodes(editor, nodes, selection);
+        return true;
+      } catch (error) {
+        logger.error('Failed to handle markdown paste:', error);
+      }
+    });
+    return false;
+  }, COMMAND_PRIORITY_HIGH // Priority
+  );
+}

package/es/plugins/markdown/data-source/markdown/parse.js

@@ -14,12 +14,13 @@ function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _d
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 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); }
+import { preprocessMarkdownContent } from '@lobehub/ui';
 import { remark } from 'remark';
+import remarkCjkFriendly from 'remark-cjk-friendly';
 import remarkGfm from 'remark-gfm';
 import remarkMath from 'remark-math';
 import { INodeHelper } from "../../../../editor-kernel/inode/helper";
 import { logger } from "../../utils/logger";
-import remarkSupersub from "./supersub";
 
 // 使用条件类型确保类型匹配
 
@@ -68,6 +69,10 @@ function convertMdastToLexical(node, index, ctx) {
           var htmlStack = []; // 当前循环是否包含 HTML 标签
           _children = node.children.reduce(function (ret, child, index) {
             if (child.type === 'html') {
+              var isComment = child.value.startsWith('<!--') && child.value.endsWith('-->');
+              if (isComment) {
+                return ret;
+              }
               var tag = child.value.replaceAll(/^<\/?|>$/g, '');
               var isEndTag = child.value.startsWith('</');
               if (selfClosingHtmlTags.has(tag)) {
@@ -221,9 +226,9 @@ function registerDefaultReaders(markdownReaders) {
 }
 export function parseMarkdownToLexical(markdown) {
   var markdownReaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var ast = remark().use(remarkMath).use(remarkSupersub).use([[remarkGfm, {
+  var ast = remark().use(remarkCjkFriendly).use(remarkMath).use([[remarkGfm, {
     singleTilde: false
-  }]]).parse(markdown);
+  }]]).parse(preprocessMarkdownContent(markdown));
   logger.debug('Parsed MDAST:', ast);
   var ctx = new MarkdownContext(ast);
   registerDefaultReaders(markdownReaders);

package/es/plugins/markdown/index.d.ts

@@ -1,4 +1,6 @@
+export { INSERT_MARKDOWN_COMMAND } from './command';
 export { MarkdownPlugin } from './plugin';
+export { default as ReactMarkdownPlugin } from './react';
 export type { MARKDOWN_READER_LEVEL } from './service/shortcut';
 export { IMarkdownShortCutService, MARKDOWN_READER_LEVEL_HIGH, MARKDOWN_READER_LEVEL_NORMAL, MARKDOWN_WRITER_LEVEL_MAX, } from './service/shortcut';
 export { isPunctuationChar } from './utils';

package/es/plugins/markdown/index.js

@@ -1,3 +1,5 @@
+export { INSERT_MARKDOWN_COMMAND } from "./command";
 export { MarkdownPlugin } from "./plugin";
+export { default as ReactMarkdownPlugin } from "./react";
 export { IMarkdownShortCutService, MARKDOWN_READER_LEVEL_HIGH, MARKDOWN_READER_LEVEL_NORMAL, MARKDOWN_WRITER_LEVEL_MAX } from "./service/shortcut";
 export { isPunctuationChar } from "./utils";

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

@@ -17,10 +17,10 @@ import { $isCodeNode } from '@lexical/code';
 import { $getNodeByKey, $getSelection, $isRangeSelection, $isTextNode, COLLABORATION_TAG, COMMAND_PRIORITY_CRITICAL, HISTORIC_TAG, KEY_ENTER_COMMAND, PASTE_COMMAND } from 'lexical';
 import { KernelPlugin } from "../../../editor-kernel/plugin";
 import { createDebugLogger } from "../../../utils/debug";
+import { registerMarkdownCommand } from "../command";
 import MarkdownDataSource from "../data-source/markdown-data-source";
-import { parseMarkdownToLexical } from "../data-source/markdown/parse";
 import { IMarkdownShortCutService, MarkdownShortCutService } from "../service/shortcut";
-import { $generateNodesFromSerializedNodes, $insertGeneratedNodes, canContainTransformableMarkdown } from "../utils";
+import { canContainTransformableMarkdown } from "../utils";
 export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(MarkdownPlugin, _KernelPlugin);
   var _super = _createSuper(MarkdownPlugin);
@@ -133,50 +133,92 @@ export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
 
         // Check if markdown paste formatting is enabled (default: true)
         var enablePasteMarkdown = (_this2$config$enableP = (_this2$config = _this2.config) === null || _this2$config === void 0 ? void 0 : _this2$config.enablePasteMarkdown) !== null && _this2$config$enableP !== void 0 ? _this2$config$enableP : true;
-        if (!enablePasteMarkdown) {
-          // Force plain text paste - ignore all formatting (like Cmd+Shift+V)
-          _this2.logger.debug('paste markdown formatting is disabled, inserting as plain text');
-          event.preventDefault();
-          event.stopPropagation();
-          editor.update(function () {
-            var selection = $getSelection();
-            if (!$isRangeSelection(selection)) return;
+        _this2.logger.debug('paste content analysis:', {
+          enablePasteMarkdown: enablePasteMarkdown,
+          hasHTML: !!(html && html.trim()),
+          text: text.slice(0, 100) + (text.length > 100 ? '...' : '')
+        });
 
-            // Simply insert the plain text
-            selection.insertText(text);
-          });
-          return true;
-        }
+        // Always force plain text paste first (prevents HTML formatting issues)
+        event.preventDefault();
+        event.stopPropagation();
+        editor.update(function () {
+          var selection = $getSelection();
+          if (!$isRangeSelection(selection)) return;
 
-        // If there's HTML content, it's a rich text paste
-        // Let Lexical's rich text handler process it
-        if (html && html.trim()) {
-          _this2.logger.debug('paste content analysis: HTML detected, letting Lexical handle it');
-          return false;
+          // Insert plain text
+          selection.insertText(text);
+        });
+
+        // If markdown formatting is disabled, we're done
+        if (!enablePasteMarkdown) {
+          _this2.logger.debug('markdown formatting disabled, plain text inserted');
+          return true;
         }
 
-        // Only handle plain text paste - check for markdown patterns
+        // Check if the pasted plain text contains markdown patterns
         var hasMarkdownContent = _this2.detectMarkdownContent(text);
-        _this2.logger.debug('paste content analysis:', {
-          hasHTML: false,
-          hasMarkdown: hasMarkdownContent,
-          markdownPatterns: _this2.getMarkdownPatterns(text),
-          text: text.slice(0, 100) + (text.length > 100 ? '...' : '')
-        });
         if (hasMarkdownContent) {
-          // Handle markdown paste
-          return _this2.handleMarkdownPaste(editor, text);
+          // Markdown detected - show confirmation dialog
+          _this2.logger.debug('markdown patterns detected:', _this2.getMarkdownPatterns(text));
+          setTimeout(function () {
+            _this2.kernel.emit('markdownParse', {
+              cacheState: editor.getEditorState(),
+              markdown: text
+            });
+          }, 10);
+        } else {
+          // No markdown detected - plain text is already inserted
+          _this2.logger.debug('no markdown patterns detected, keeping as plain text');
         }
-        return false;
+        return true; // Command handled
       }, COMMAND_PRIORITY_CRITICAL));
+      this.register(registerMarkdownCommand(editor, this.service));
     }
 
     /**
      * Detect if text contains markdown patterns
+     * Returns false if content is likely code (JSON, HTML, SQL, etc.)
      */
   }, {
     key: "detectMarkdownContent",
     value: function detectMarkdownContent(text) {
+      var trimmed = text.trim();
+
+      // Check if content is JSON
+      if (trimmed.startsWith('{') && trimmed.endsWith('}') || trimmed.startsWith('[') && trimmed.endsWith(']')) {
+        try {
+          JSON.parse(trimmed);
+          this.logger.debug('content is valid JSON, not treating as markdown');
+          return false;
+        } catch (_unused) {
+          // Not valid JSON, continue checking
+        }
+      }
+
+      // Check if content has significant HTML structure
+      var htmlTagPattern = /<[a-z][\S\s]*?>/gi;
+      var htmlMatches = text.match(htmlTagPattern);
+      if (htmlMatches && htmlMatches.length > 5) {
+        // More than 5 HTML tags suggests this is HTML content, not markdown
+        this.logger.debug('content has significant HTML structure, not treating as markdown');
+        return false;
+      }
+
+      // Check if content looks like code (SQL, XML, etc.)
+      // Common patterns: SQL keywords, XML declarations, file paths
+      var codePatterns = [/^\s*(select|insert|update|delete|create|alter|drop)\s+/im,
+      // SQL
+      /^\s*<\?xml/i,
+      // XML declaration
+      /^[a-z]:\\|^\/[a-z]/im // File paths (Windows/Unix)
+      ];
+      if (codePatterns.some(function (pattern) {
+        return pattern.test(text);
+      })) {
+        this.logger.debug('content looks like code, not treating as markdown');
+        return false;
+      }
       var markdownPatterns = [
       // Headers
       /^#{1,6}\s+/m,
@@ -260,24 +302,23 @@ export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       });
     }
 
-    /**
-     * Handle markdown paste by parsing and inserting as structured content
-     */
-  }, {
-    key: "handleMarkdownPaste",
-    value: function handleMarkdownPaste(editor, text) {
-      try {
-        // Use the markdown data source to parse the content
-        var root = parseMarkdownToLexical(text, this.service.markdownReaders);
-        var selection = $getSelection();
-        var nodes = $generateNodesFromSerializedNodes(root.children);
-        $insertGeneratedNodes(editor, nodes, selection);
-        return true;
-      } catch (error) {
-        this.logger.error('Failed to handle markdown paste:', error);
-      }
-      return false;
-    }
+    // /**
+    //  * Handle markdown paste by parsing and inserting as structured content
+    //  */
+    // private handleMarkdownPaste(editor: LexicalEditor, text: string): boolean {
+    //   try {
+    //     // Use the markdown data source to parse the content
+    //     const root = parseMarkdownToLexical(text, this.service.markdownReaders);
+    //     const selection = $getSelection();
+    //     const nodes = $generateNodesFromSerializedNodes(root.children);
+    //     $insertGeneratedNodes(editor, nodes, selection!);
+    //     return true;
+    //   } catch (error) {
+    //     this.logger.error('Failed to handle markdown paste:', error);
+    //   }
+
+    //   return false;
+    // }
   }]);
   return MarkdownPlugin;
 }(KernelPlugin), _defineProperty(_class, "pluginName", 'MarkdownPlugin'), _class);

package/es/plugins/markdown/react/index.d.ts

@@ -0,0 +1,3 @@
+import { type FC } from 'react';
+declare const ReactMarkdownPlugin: FC<void>;
+export default ReactMarkdownPlugin;

package/es/plugins/markdown/react/index.js

@@ -0,0 +1,70 @@
+'use client';
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+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; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { Button } from '@lobehub/ui';
+import { Space, notification } from 'antd';
+import { UNDO_COMMAND } from 'lexical';
+import { useLayoutEffect } from 'react';
+import { useLexicalComposerContext } from "../../../editor-kernel/react";
+import { useTranslation } from "../../../editor-kernel/react/useTranslation";
+import { INSERT_MARKDOWN_COMMAND } from "../command";
+import { MarkdownPlugin } from "../plugin";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var ReactMarkdownPlugin = function ReactMarkdownPlugin() {
+  var _useLexicalComposerCo = useLexicalComposerContext(),
+    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
+    editor = _useLexicalComposerCo2[0];
+  var _notification$useNoti = notification.useNotification(),
+    _notification$useNoti2 = _slicedToArray(_notification$useNoti, 2),
+    api = _notification$useNoti2[0],
+    contextHolder = _notification$useNoti2[1];
+  var t = useTranslation();
+  useLayoutEffect(function () {
+    editor.registerPlugin(MarkdownPlugin);
+    var handleEvent = function handleEvent(_ref) {
+      var markdown = _ref.markdown;
+      var key = "open".concat(Date.now());
+      var actions = /*#__PURE__*/_jsxs(Space, {
+        children: [/*#__PURE__*/_jsx(Button, {
+          onClick: function onClick() {
+            return api.destroy();
+          },
+          size: "small",
+          children: t('markdown.cancel')
+        }), /*#__PURE__*/_jsx(Button, {
+          onClick: function onClick() {
+            editor.dispatchCommand(UNDO_COMMAND, undefined);
+            editor.dispatchCommand(INSERT_MARKDOWN_COMMAND, {
+              markdown: markdown
+            });
+            api.destroy();
+          },
+          size: "small",
+          type: "primary",
+          children: t('markdown.confirm')
+        })]
+      });
+      api.open({
+        actions: actions,
+        description: t('markdown.parseMessage'),
+        duration: 5,
+        key: key,
+        message: t('markdown.parseTitle'),
+        showProgress: true
+      });
+    };
+    editor.on('markdownParse', handleEvent);
+    return function () {
+      editor.off('markdownParse', handleEvent);
+    };
+  }, [editor]);
+  return contextHolder;
+};
+ReactMarkdownPlugin.displayName = 'ReactMarkdownPlugin';
+export default ReactMarkdownPlugin;

package/es/types/kernel.d.ts

@@ -1,4 +1,4 @@
-import type { CommandListener, CommandListenerPriority, CommandPayloadType, DecoratorNode, LexicalCommand, LexicalEditor, LexicalNodeConfig } from 'lexical';
+import type { CommandListener, CommandListenerPriority, CommandPayloadType, DecoratorNode, EditorState, LexicalCommand, LexicalEditor, LexicalNodeConfig } from 'lexical';
 import type DataSource from "../editor-kernel/data-source";
 import { HotkeyId } from "./hotkey";
 import { HotkeyOptions, HotkeysEvent } from "../utils/hotkey/registerHotkey";
@@ -23,6 +23,13 @@ export interface IKernelEventMap {
      * @returns
      */
     initialized: (editor: LexicalEditor) => void;
+    /**
+     * handle markdown parse event
+     */
+    markdownParse: (params: {
+        cacheState: EditorState;
+        markdown: string;
+    }) => void;
 }
 /**
  * External API
@@ -175,6 +182,7 @@ export interface IEditor {
  * API provided to plugins
  */
 export interface IEditorKernel extends IEditor {
+    emit<T extends keyof IKernelEventMap>(event: T, params: Parameters<IKernelEventMap[T]>[0]): void;
     /**
      * Get editor Node decorator for specific Node rendering
      * @param name

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/editor",
-  "version": "1.16.3",
+  "version": "1.17.1",
   "description": "A powerful and extensible rich text editor built on Meta's Lexical framework, providing a modern editing experience with React integration.",
   "keywords": [
     "lobehub",
@@ -56,6 +56,7 @@
     "react-error-boundary": "^6.0.0",
     "react-layout-kit": "^2.0.0",
     "react-merge-refs": "^3.0.2",
+    "remark-cjk-friendly": "^1.2.1",
     "remark-supersub": "^1.0.0",
     "shiki": "^3.9.2",
     "ts-key-enum": "^3.0.13",