@lobehub/editor 1.12.0 → 1.14.0

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

@@ -13,7 +13,7 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 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 { $setSelection } from 'lexical';
+import { $setSelection, TextNode } from 'lexical';
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
 import { $createCursorNode, cursorNodeSerialized } from "../../common";
@@ -44,6 +44,11 @@ export var CodePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       this.register(registerCodeInline(editor, this.kernel, {
         enableHotkey: (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enableHotkey
       }));
+      this.register(editor.registerNodeTransform(TextNode, function (node) {
+        if (node.hasFormat('code')) {
+          node.replace($createCodeNode(node.getTextContent())).insertAfter($createCursorNode());
+        }
+      }));
       var markdownService = this.kernel.requireService(IMarkdownShortCutService);
       if (!markdownService) {
         return;

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

@@ -1,4 +1,4 @@
-import { IS_BOLD, IS_ITALIC, IS_STRIKETHROUGH, IS_SUBSCRIPT, IS_SUPERSCRIPT } from 'lexical';
+import { IS_BOLD, IS_ITALIC, IS_STRIKETHROUGH, IS_SUBSCRIPT, IS_SUPERSCRIPT, IS_UNDERLINE } from 'lexical';
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
 export function registerMDReader(markdownService) {
   markdownService.registerMarkdownReader('blockquote', function (node, children) {
@@ -56,4 +56,29 @@ export function registerMDReader(markdownService) {
       return child;
     });
   });
+  markdownService.registerMarkdownReader('html', function (node, children) {
+    if (['<ins>', '<u>'].includes(node.value.toLocaleLowerCase())) {
+      return children.map(function (child) {
+        if (INodeHelper.isTextNode(child)) {
+          child.format = (child.format || 0) | IS_UNDERLINE;
+        }
+        return child;
+      });
+    } else if (['<em>'].includes(node.value.toLocaleLowerCase())) {
+      return children.map(function (child) {
+        if (INodeHelper.isTextNode(child)) {
+          child.format = (child.format || 0) | IS_ITALIC;
+        }
+        return child;
+      });
+    } else if (['<strong>'].includes(node.value.toLocaleLowerCase())) {
+      return children.map(function (child) {
+        if (INodeHelper.isTextNode(child)) {
+          child.format = (child.format || 0) | IS_BOLD;
+        }
+        return child;
+      });
+    }
+    return false;
+  });
 }

package/es/plugins/markdown/data-source/markdown/parse.d.ts

@@ -1,10 +1,21 @@
-import type { PhrasingContent, RootContent } from 'mdast';
+import type { Html, PhrasingContent, Root, RootContent } from 'mdast';
 import type { IElementNode, INode, IRootNode, ITextNode } from "../../../../editor-kernel/inode";
 export type MarkdownReadNode = INode | ITextNode | IElementNode;
-export type MarkdownNode = RootContent | PhrasingContent;
+export type MarkdownNode = Root | RootContent | PhrasingContent;
+export type MarkdownReaderFunc<K> = (node: Extract<MarkdownNode, {
+    type: K;
+}>, children: MarkdownReadNode[], index: number) => MarkdownReadNode | MarkdownReadNode[] | false;
 export type TransformerRecord = {
-    [K in MarkdownNode['type']]?: (node: Extract<MarkdownNode, {
-        type: K;
-    }>, children: MarkdownReadNode[], index: number) => MarkdownReadNode | MarkdownReadNode[];
+    [K in MarkdownNode['type']]?: MarkdownReaderFunc<K> | Array<MarkdownReaderFunc<K>>;
 };
+export type TransfromerRecordArray = {
+    [K in MarkdownNode['type']]?: Array<MarkdownReaderFunc<K>>;
+};
+export interface IHTMLStack {
+    children: Array<MarkdownReadNode[] | MarkdownReadNode | null>;
+    index: number;
+    isEndTag: boolean;
+    node: Html;
+    tag: string;
+}
 export declare function parseMarkdownToLexical(markdown: string, markdownReaders?: TransformerRecord): IRootNode;

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

@@ -1,6 +1,16 @@
 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 ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+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; }
+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 _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); }
@@ -13,57 +23,166 @@ import remarkSupersub from "./supersub";
 
 // 使用条件类型确保类型匹配
 
-function convertMdastToLexical(node, index) {
-  var markdownReaders = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+var selfClosingHtmlTags = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+var MarkdownContext = /*#__PURE__*/function () {
+  function MarkdownContext(root) {
+    _classCallCheck(this, MarkdownContext);
+    _defineProperty(this, "stack", []);
+    this.root = root;
+  }
+  _createClass(MarkdownContext, [{
+    key: "push",
+    value: function push(html) {
+      this.stack.push(html);
+    }
+  }, {
+    key: "isReadingHTML",
+    get: function get() {
+      return this.stack.length > 0;
+    }
+  }, {
+    key: "last",
+    get: function get() {
+      return this.stack.at(-1);
+    }
+  }, {
+    key: "pop",
+    value: function pop() {
+      return this.stack.pop();
+    }
+  }]);
+  return MarkdownContext;
+}();
+function convertMdastToLexical(node, index, ctx) {
+  var markdownReaders = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
   switch (node.type) {
-    case 'root':
-      {
-        return _objectSpread(_objectSpread({}, INodeHelper.createRootNode()), {}, {
-          children: node.children.map(function (child, index) {
-            return convertMdastToLexical(child, index, markdownReaders);
-          }).filter(Boolean).flat()
-        });
-      }
-    case 'paragraph':
-      {
-        var paragraph = INodeHelper.createParagraph();
-        return _objectSpread(_objectSpread({}, paragraph), {}, {
-          children: node.children.map(function (child, index) {
-            return convertMdastToLexical(child, index, markdownReaders);
-          }).filter(Boolean).flat()
-        });
-      }
-    case 'heading':
-      {
-        // Create heading based on depth (h1-h6)
-        var headingType = "h".concat(Math.min(Math.max(node.depth, 1), 6));
-        return INodeHelper.createElementNode('heading', {
-          children: node.children.map(function (child, index) {
-            return convertMdastToLexical(child, index, markdownReaders);
-          }).filter(Boolean).flat(),
-          direction: 'ltr',
-          format: '',
-          indent: 0,
-          tag: headingType
-        });
-      }
     case 'text':
       {
-        return INodeHelper.createTextNode(node.value);
+        var textNode = INodeHelper.createTextNode(node.value);
+        return textNode;
       }
     default:
       {
         if (markdownReaders[node.type]) {
-          var _markdownReaders$node;
           var _children = [];
           if ('children' in node && Array.isArray(node.children)) {
-            _children = node.children.map(function (child, index) {
-              return convertMdastToLexical(child, index, markdownReaders);
-            }).filter(Boolean).flat();
+            var htmlStack = []; // 当前循环是否包含 HTML 标签
+            _children = node.children.reduce(function (ret, child, index) {
+              if (child.type === 'html') {
+                var tag = child.value.replaceAll(/^<\/?|>$/g, '');
+                var isEndTag = child.value.startsWith('</');
+                if (selfClosingHtmlTags.has(tag)) {
+                  // Self-closing tag
+                  var _reader = markdownReaders['html'];
+                  if (Array.isArray(_reader)) {
+                    var _iterator = _createForOfIteratorHelper(_reader),
+                      _step;
+                    try {
+                      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                        var element = _step.value;
+                        var inode = element(child, [], index);
+                        if (inode) {
+                          ret.push(inode);
+                          return ret;
+                        }
+                      }
+                    } catch (err) {
+                      _iterator.e(err);
+                    } finally {
+                      _iterator.f();
+                    }
+                  } else if (typeof _reader === 'function') {
+                    var _inode = _reader(child, [], index);
+                    if (_inode) {
+                      ret.push(_inode);
+                      return ret;
+                    }
+                  }
+                  return ret;
+                }
+                if (isEndTag) {
+                  var top = ctx.pop();
+                  htmlStack.pop();
+                  if ((top === null || top === void 0 ? void 0 : top.tag) !== tag) {
+                    logger.warn('HTML tag mismatch:', tag);
+                    ret.push.apply(ret, _toConsumableArray((top === null || top === void 0 ? void 0 : top.children) || []));
+                    return ret;
+                  }
+                  var _reader2 = markdownReaders['html'];
+                  var _children2 = top.children.flat().filter(Boolean) || [];
+                  if (Array.isArray(_reader2)) {
+                    var _iterator2 = _createForOfIteratorHelper(_reader2),
+                      _step2;
+                    try {
+                      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                        var _element = _step2.value;
+                        var _inode2 = _element(top.node, _children2, index);
+                        if (_inode2) {
+                          ret.push(_inode2);
+                          return ret;
+                        }
+                      }
+                    } catch (err) {
+                      _iterator2.e(err);
+                    } finally {
+                      _iterator2.f();
+                    }
+                  } else if (typeof _reader2 === 'function') {
+                    var _inode3 = _reader2(top.node, _children2, index);
+                    if (_inode3) {
+                      ret.push(_inode3);
+                      return ret;
+                    }
+                  }
+                  if (top) {
+                    ret.push.apply(ret, _toConsumableArray(top.children));
+                  }
+                  return ret;
+                }
+                var htmlStackItem = {
+                  children: [],
+                  index: index,
+                  isEndTag: isEndTag,
+                  node: child,
+                  tag: tag
+                };
+                htmlStack.push(htmlStackItem);
+                ctx.push(htmlStackItem);
+                return ret;
+              }
+              if (htmlStack.length > 0) {
+                var _top = ctx.last;
+                if (_top) {
+                  _top.children.push(convertMdastToLexical(child, index, ctx, markdownReaders));
+                }
+                return ret;
+              }
+              ret.push(convertMdastToLexical(child, index, ctx, markdownReaders));
+              return ret;
+            }, []).filter(Boolean).flat();
           }
-          var inode = (_markdownReaders$node = markdownReaders[node.type]) === null || _markdownReaders$node === void 0 ? void 0 : _markdownReaders$node.call(markdownReaders, node, _children, index);
-          if (inode) {
-            return inode;
+          var reader = markdownReaders[node.type];
+          if (Array.isArray(reader)) {
+            var _iterator3 = _createForOfIteratorHelper(reader),
+              _step3;
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var element = _step3.value;
+                var inode = element(node, _children, index);
+                if (inode) {
+                  return inode;
+                }
+              }
+            } catch (err) {
+              _iterator3.e(err);
+            } finally {
+              _iterator3.f();
+            }
+          } else if (typeof reader === 'function') {
+            var _inode4 = reader(node, _children, index);
+            if (_inode4) {
+              return _inode4;
+            }
           }
         }
 
@@ -72,11 +191,41 @@ function convertMdastToLexical(node, index) {
       }
   }
 }
+function registerDefaultReaders(markdownReaders) {
+  if (!markdownReaders['root']) {
+    markdownReaders['root'] = function (node, children) {
+      return _objectSpread(_objectSpread({}, INodeHelper.createRootNode()), {}, {
+        children: children
+      });
+    };
+  }
+  if (!markdownReaders['paragraph']) {
+    markdownReaders['paragraph'] = function (node, children) {
+      return _objectSpread(_objectSpread({}, INodeHelper.createParagraph()), {}, {
+        children: children
+      });
+    };
+  }
+  if (!markdownReaders['heading']) {
+    markdownReaders['heading'] = function (node, children) {
+      var headingType = "h".concat(Math.min(Math.max(node.depth, 1), 6));
+      return INodeHelper.createElementNode('heading', {
+        children: children,
+        direction: 'ltr',
+        format: '',
+        indent: 0,
+        tag: headingType
+      });
+    };
+  }
+}
 export function parseMarkdownToLexical(markdown) {
   var markdownReaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var ast = remark().use(remarkMath).use(remarkSupersub).use([[remarkGfm, {
     singleTilde: false
   }]]).parse(markdown);
   logger.debug('Parsed MDAST:', ast);
-  return convertMdastToLexical(ast, 0, markdownReaders);
+  var ctx = new MarkdownContext(ast);
+  registerDefaultReaders(markdownReaders);
+  return convertMdastToLexical(ast, 0, ctx, markdownReaders);
 }

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

@@ -1,3 +1,4 @@
 export { MarkdownPlugin } from './plugin';
-export { IMarkdownShortCutService } from './service/shortcut';
+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,3 @@
 export { MarkdownPlugin } from "./plugin";
-export { IMarkdownShortCutService } 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/service/shortcut.d.ts

@@ -1,6 +1,6 @@
 import { ElementNode, LexicalNode, TextNode } from 'lexical';
 import type { IEditorKernel, IServiceID } from "../../../types/kernel";
-import type { TransformerRecord } from '../data-source/markdown/parse';
+import type { MarkdownReaderFunc, TransformerRecord, TransfromerRecordArray } from '../data-source/markdown/parse';
 import type { Transformer } from './transformers';
 export interface IMarkdownWriterContext {
     /**
@@ -22,11 +22,15 @@ export interface IMarkdownWriterContext {
      */
     wrap: (before: string, after: string) => void;
 }
+export declare const MARKDOWN_WRITER_LEVEL_MAX = 0;
+export declare const MARKDOWN_READER_LEVEL_HIGH = 1;
+export declare const MARKDOWN_READER_LEVEL_NORMAL = 2;
+export type MARKDOWN_READER_LEVEL = typeof MARKDOWN_READER_LEVEL_HIGH | typeof MARKDOWN_READER_LEVEL_NORMAL | typeof MARKDOWN_WRITER_LEVEL_MAX;
 export interface IMarkdownShortCutService {
     /**
      * Register Markdown reader
      */
-    registerMarkdownReader<K extends keyof TransformerRecord>(type: K, reader: TransformerRecord[K]): void;
+    registerMarkdownReader<K extends keyof TransformerRecord>(type: K, reader: MarkdownReaderFunc<K>, level?: MARKDOWN_READER_LEVEL): void;
     registerMarkdownShortCut(transformer: Transformer): void;
     registerMarkdownShortCuts(transformers: Transformer[]): void;
     /**
@@ -47,7 +51,7 @@ export declare class MarkdownShortCutService implements IMarkdownShortCutService
     private _markdownReaders;
     constructor(kernel?: IEditorKernel | undefined);
     get markdownWriters(): Record<string, (_ctx: IMarkdownWriterContext, _node: LexicalNode) => boolean | void>;
-    get markdownReaders(): TransformerRecord;
+    get markdownReaders(): TransfromerRecordArray;
     private _textFormatTransformersByTrigger;
     private _textMatchTransformersByTrigger;
     get textMatchTransformersByTrigger(): Readonly<Record<string, Readonly<{
@@ -70,5 +74,5 @@ export declare class MarkdownShortCutService implements IMarkdownShortCutService
     testTransformers(parentNode: ElementNode, anchorNode: TextNode, anchorOffset: number, trigger?: 'enter'): boolean;
     runTransformers(parentNode: ElementNode, anchorNode: TextNode, anchorOffset: number, trigger?: 'enter'): boolean;
     registerMarkdownWriter(type: string, writer: (ctx: IMarkdownWriterContext, node: LexicalNode) => boolean | void): void;
-    registerMarkdownReader<K extends keyof TransformerRecord>(type: K, reader: TransformerRecord[K]): void;
+    registerMarkdownReader<K extends keyof TransformerRecord>(type: K, reader: MarkdownReaderFunc<K>, level?: MARKDOWN_READER_LEVEL): void;
 }

package/es/plugins/markdown/service/shortcut.js

@@ -1,6 +1,10 @@
 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 _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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread 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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 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 _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); } }
@@ -15,6 +19,9 @@ import { genServiceId } from "../../../editor-kernel";
 import { createDebugLogger } from "../../../utils/debug";
 import { indexBy } from "../utils";
 import { $runTextFormatTransformers, runElementTransformers, runTextMatchTransformers, testElementTransformers } from "./transformers";
+export var MARKDOWN_WRITER_LEVEL_MAX = 0;
+export var MARKDOWN_READER_LEVEL_HIGH = 1;
+export var MARKDOWN_READER_LEVEL_NORMAL = 2;
 export var IMarkdownShortCutService = genServiceId('MarkdownShortCutService');
 export var MarkdownShortCutService = /*#__PURE__*/function () {
   function MarkdownShortCutService(kernel) {
@@ -24,7 +31,7 @@ export var MarkdownShortCutService = /*#__PURE__*/function () {
     _defineProperty(this, "textMatchTransformers", []);
     _defineProperty(this, "logger", createDebugLogger('service', 'markdown'));
     _defineProperty(this, "_markdownWriters", {});
-    _defineProperty(this, "_markdownReaders", {});
+    _defineProperty(this, "_markdownReaders", [{}, {}, {}]);
     _defineProperty(this, "_textFormatTransformersByTrigger", null);
     _defineProperty(this, "_textMatchTransformersByTrigger", null);
     this.kernel = kernel;
@@ -37,7 +44,18 @@ export var MarkdownShortCutService = /*#__PURE__*/function () {
   }, {
     key: "markdownReaders",
     get: function get() {
-      return this._markdownReaders;
+      return this._markdownReaders.reduce(function (acc, curr) {
+        // @ts-expect-error not error
+        Object.keys(curr).forEach(function (key) {
+          if (!acc[key]) {
+            acc[key] = [];
+          }
+          var existing = acc[key];
+          var adding = curr[key];
+          existing.push.apply(existing, _toConsumableArray(adding));
+        });
+        return acc;
+      }, {});
     }
   }, {
     key: "textMatchTransformersByTrigger",
@@ -142,17 +160,14 @@ export var MarkdownShortCutService = /*#__PURE__*/function () {
   }, {
     key: "registerMarkdownReader",
     value: function registerMarkdownReader(type, reader) {
-      var _this$kernel2;
-      if (!this._markdownReaders[type]) {
-        this._markdownReaders[type] = reader;
-        return;
+      var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : MARKDOWN_READER_LEVEL_NORMAL;
+      if (!this._markdownReaders[level][type]) {
+        this._markdownReaders[level][type] = [];
       }
-      if ((_this$kernel2 = this.kernel) !== null && _this$kernel2 !== void 0 && _this$kernel2.isHotReloadMode()) {
-        this.logger.warn("\uD83D\uDD04 Hot reload: markdown reader \"".concat(type, "\""));
-        this._markdownReaders[type] = reader;
-        return;
+      if (this._markdownReaders[level]) {
+        var _this$_markdownReader;
+        (_this$_markdownReader = this._markdownReaders[level][type]) === null || _this$_markdownReader === void 0 || _this$_markdownReader.push(reader);
       }
-      throw new Error("Markdown reader for type \"".concat(type, "\" is already registered."));
     }
   }]);
   return MarkdownShortCutService;

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

@@ -1,3 +1,4 @@
 export { INSERT_MENTION_COMMAND } from './command';
+export type { SerializedMentionNode } from './node/MentionNode';
 export * from './plugin';
 export * from './react';

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

@@ -1,8 +1,11 @@
 import { LexicalEditor } from 'lexical';
+import { Html } from 'mdast';
+import { INode } from "../../../editor-kernel/inode";
 import type { IEditorPluginConstructor } from "../../../types";
-import { MentionNode } from '../node/MentionNode';
+import { MentionNode, SerializedMentionNode } from '../node/MentionNode';
 export interface MentionPluginOptions {
     decorator: (node: MentionNode, editor: LexicalEditor) => any;
+    markdownReader?: (node: Html, children: INode[]) => SerializedMentionNode | null | false;
     markdownWriter?: (file: MentionNode) => string;
     theme?: {
         mention?: string;

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

@@ -14,7 +14,7 @@ function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key i
 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 { KernelPlugin } from "../../../editor-kernel/plugin";
-import { IMarkdownShortCutService } from "../../markdown";
+import { IMarkdownShortCutService, MARKDOWN_READER_LEVEL_HIGH } from "../../markdown";
 import { registerMentionCommand } from "../command";
 import { $isMentionNode, MentionNode } from "../node/MentionNode";
 import { registerMentionNodeSelectionObserver } from "./register";
@@ -25,7 +25,6 @@ export var MentionPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(MentionPlugin, _KernelPlugin);
   var _super = _createSuper(MentionPlugin);
   function MentionPlugin(kernel, config) {
-    var _kernel$requireServic;
     var _this;
     _classCallCheck(this, MentionPlugin);
     _this = _super.call(this);
@@ -39,15 +38,6 @@ export var MentionPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     _this.registerDecorator(kernel, MentionNode.getType(), function (node, editor) {
       return config !== null && config !== void 0 && config.decorator ? config.decorator(node, editor) : null;
     });
-    (_kernel$requireServic = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic === void 0 || _kernel$requireServic.registerMarkdownWriter(MentionNode.getType(), function (ctx, node) {
-      if ($isMentionNode(node)) {
-        if (config !== null && config !== void 0 && config.markdownWriter) {
-          ctx.appendLine(config.markdownWriter(node));
-          return;
-        }
-        ctx.appendLine("".concat(node.label));
-      }
-    });
     return _this;
   }
   _createClass(MentionPlugin, [{
@@ -55,6 +45,32 @@ export var MentionPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     value: function onInit(editor) {
       this.register(registerMentionCommand(editor));
       this.register(registerMentionNodeSelectionObserver(editor));
+      this.registerMarkdown();
+    }
+  }, {
+    key: "registerMarkdown",
+    value: function registerMarkdown() {
+      var _this$kernel$requireS,
+        _this2 = this,
+        _this$config;
+      (_this$kernel$requireS = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS === void 0 || _this$kernel$requireS.registerMarkdownWriter(MentionNode.getType(), function (ctx, node) {
+        if ($isMentionNode(node)) {
+          var _this2$config;
+          if ((_this2$config = _this2.config) !== null && _this2$config !== void 0 && _this2$config.markdownWriter) {
+            ctx.appendLine(_this2.config.markdownWriter(node));
+            return;
+          }
+          ctx.appendLine("".concat(node.label));
+        }
+      });
+      if ((_this$config = this.config) !== null && _this$config !== void 0 && _this$config.markdownReader) {
+        var _this$kernel$requireS2;
+        (_this$kernel$requireS2 = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS2 === void 0 || _this$kernel$requireS2.registerMarkdownReader('html', function (node, children) {
+          var _this2$config2;
+          return (_this2$config2 = _this2.config) !== null && _this2$config2 !== void 0 && _this2$config2.markdownReader ? _this2.config.markdownReader(node, children) || false : false;
+          // return this.config?.markdownReader ? this.config.markdownReader(node, children) || false : false;
+        }, MARKDOWN_READER_LEVEL_HIGH);
+      }
     }
   }]);
   return MentionPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/editor",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "description": "A powerful and extensible rich text editor built on Meta's Lexical framework, providing a modern editing experience with React integration.",
   "keywords": [
     "lobehub",