@lobehub/editor 1.11.0 → 1.13.0

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

@@ -0,0 +1,231 @@
+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); }
+import { remark } from 'remark';
+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";
+
+// 使用条件类型确保类型匹配
+
+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 'text':
+      {
+        var textNode = INodeHelper.createTextNode(node.value);
+        return textNode;
+      }
+    default:
+      {
+        if (markdownReaders[node.type]) {
+          var _children = [];
+          if ('children' in node && Array.isArray(node.children)) {
+            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 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;
+            }
+          }
+        }
+
+        // Fallback for unsupported nodes
+        return null;
+      }
+  }
+}
+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);
+  var ctx = new MarkdownContext(ast);
+  registerDefaultReaders(markdownReaders);
+  return convertMdastToLexical(ast, 0, ctx, markdownReaders);
+}

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

@@ -0,0 +1 @@
+export default function remarkSupersub(): void;

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

@@ -0,0 +1,14 @@
+/* eslint-disable @typescript-eslint/no-this-alias */
+/* eslint-disable @typescript-eslint/no-invalid-this */
+/* eslint-disable unused-imports/no-unused-vars */
+import supersub from 'remark-supersub';
+export default function remarkSupersub() {
+  // @ts-expect-error: TS is wrong about `this`.
+  // eslint-disable-next-line unicorn/no-this-assignment
+  var self = /** @type {Processor} */this;
+  var data = self.data();
+  var fromMarkdownExtensions = data.fromMarkdownExtensions || (data.fromMarkdownExtensions = []);
+  fromMarkdownExtensions.push({
+    transforms: [supersub()]
+  });
+}

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

@@ -1,11 +1,11 @@
-import { LexicalEditor } from 'lexical';
+import type { LexicalEditor } from 'lexical';
 import { DataSource } from "../../../editor-kernel";
-import { IWriteOptions } from "../../../editor-kernel/data-source";
-import { MarkdownShortCutService } from '../service/shortcut';
+import type { IWriteOptions } from "../../../editor-kernel/data-source";
+import type { MarkdownShortCutService } from '../service/shortcut';
 export default class MarkdownDataSource extends DataSource {
     protected dataType: string;
     protected markdownService: MarkdownShortCutService;
     constructor(dataType: string, markdownService: MarkdownShortCutService);
-    read(): void;
+    read(editor: LexicalEditor, data: string): void;
     write(editor: LexicalEditor, options?: IWriteOptions): any;
 }

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

@@ -29,7 +29,9 @@ import { $isTableSelection } from '@lexical/table';
 import { $getCharacterOffsets, $getNodeByKey, $getRoot, $getSelection, $isElementNode, $isRangeSelection, $isTextNode } from 'lexical';
 import { DataSource } from "../../../editor-kernel";
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
+import { logger } from "../utils/logger";
 import { MarkdownWriterContext } from "./markdown-writer-context";
+import { parseMarkdownToLexical } from "./markdown/parse";
 var MarkdownDataSource = /*#__PURE__*/function (_DataSource) {
   _inherits(MarkdownDataSource, _DataSource);
   var _super = _createSuper(MarkdownDataSource);
@@ -43,8 +45,12 @@ var MarkdownDataSource = /*#__PURE__*/function (_DataSource) {
   }
   _createClass(MarkdownDataSource, [{
     key: "read",
-    value: function read() {
-      throw new Error('MarkdownDataSource not implemented yet!');
+    value: function read(editor, data) {
+      var inode = {
+        root: parseMarkdownToLexical(data, this.markdownService.markdownReaders)
+      };
+      logger.debug('Parsed Lexical State:', inode);
+      editor.setEditorState(editor.parseEditorState(inode));
     }
   }, {
     key: "write",

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/plugin/index.js

@@ -14,11 +14,12 @@ 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 { $isCodeNode } from '@lexical/code';
-import { $getNodeByKey, $getSelection, $isRangeSelection, $isTextNode, COLLABORATION_TAG, COMMAND_PRIORITY_CRITICAL, HISTORIC_TAG, KEY_ENTER_COMMAND } from 'lexical';
+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 MarkdownDataSource from "../data-source/markdown-data-source";
+import { parseMarkdownToLexical } from "../data-source/markdown/parse";
 import { IMarkdownShortCutService, MarkdownShortCutService } from "../service/shortcut";
-import { canContainTransformableMarkdown } from "../utils";
+import { $generateNodesFromSerializedNodes, $insertGeneratedNodes, canContainTransformableMarkdown } from "../utils";
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
 
@@ -117,6 +118,138 @@ export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         }
         return false;
       }, COMMAND_PRIORITY_CRITICAL));
+      this.register(editor.registerCommand(PASTE_COMMAND, function (event) {
+        if (!(event instanceof ClipboardEvent)) return false;
+        var clipboardData = event.clipboardData;
+        if (!clipboardData) return false;
+
+        // Get plain text content
+        var text = clipboardData.getData('text/plain');
+        var html = clipboardData.getData('text/html');
+        if (!text) return false;
+
+        // Check if content contains markdown patterns
+        var hasMarkdownContent = _this2.detectMarkdownContent(text);
+        console.log('paste content analysis:', {
+          hasHTML: !!html,
+          hasMarkdown: hasMarkdownContent,
+          markdownPatterns: _this2.getMarkdownPatterns(text),
+          text: text.slice(0, 100) + (text.length > 100 ? '...' : '')
+        });
+        if (hasMarkdownContent) {
+          // Handle markdown paste
+          return _this2.handleMarkdownPaste(editor, text);
+        }
+        return false;
+      }, COMMAND_PRIORITY_CRITICAL));
+    }
+
+    /**
+     * Detect if text contains markdown patterns
+     */
+  }, {
+    key: "detectMarkdownContent",
+    value: function detectMarkdownContent(text) {
+      var markdownPatterns = [
+      // Headers
+      /^#{1,6}\s+/m,
+      // Bold/italic
+      /\*{1,2}[^*]+\*{1,2}/, /__?[^_]+__?/,
+      // Code blocks
+      /```[\S\s]*```/,
+      // Inline code
+      /`[^`]+`/,
+      // Links
+      /\[[^\]]*]\([^)]+\)/,
+      // Images
+      /!\[[^\]]*]\([^)]+\)/,
+      // Lists
+      /^[*+-]\s+/m, /^\d+\.\s+/m,
+      // Blockquotes
+      /^>\s+/m,
+      // Tables
+      /\|.*\|.*\|/,
+      // Horizontal rules
+      /^---+$/m, /^\*\*\*+$/m,
+      // Strikethrough
+      /~~[^~]+~~/];
+      return markdownPatterns.some(function (pattern) {
+        return pattern.test(text);
+      });
+    }
+
+    /**
+     * Get specific markdown patterns found in text
+     */
+  }, {
+    key: "getMarkdownPatterns",
+    value: function getMarkdownPatterns(text) {
+      var patterns = [{
+        name: 'headers',
+        regex: /^#{1,6}\s+/m
+      }, {
+        name: 'bold',
+        regex: /\*{2}[^*]+\*{2}/
+      }, {
+        name: 'italic',
+        regex: /\*[^*]+\*/
+      }, {
+        name: 'code-blocks',
+        regex: /```[\S\s]*```/
+      }, {
+        name: 'inline-code',
+        regex: /`[^`]+`/
+      }, {
+        name: 'links',
+        regex: /\[[^\]]*]\([^)]+\)/
+      }, {
+        name: 'images',
+        regex: /!\[[^\]]*]\([^)]+\)/
+      }, {
+        name: 'lists',
+        regex: /^[*+-]\s+/m
+      }, {
+        name: 'ordered-lists',
+        regex: /^\d+\.\s+/m
+      }, {
+        name: 'blockquotes',
+        regex: /^>\s+/m
+      }, {
+        name: 'tables',
+        regex: /\|.*\|.*\|/
+      }, {
+        name: 'horizontal-rules',
+        regex: /^---+$/m
+      }, {
+        name: 'strikethrough',
+        regex: /~~[^~]+~~/
+      }];
+      return patterns.filter(function (_ref2) {
+        var regex = _ref2.regex;
+        return regex.test(text);
+      }).map(function (_ref3) {
+        var name = _ref3.name;
+        return name;
+      });
+    }
+
+    /**
+     * 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) {
+        console.error('Failed to handle markdown paste:', error);
+      }
+      return false;
     }
   }]);
   return MarkdownPlugin;

package/es/plugins/markdown/service/shortcut.d.ts

@@ -1,60 +1,7 @@
-import { ElementNode, LexicalNode, RangeSelection, TextFormatType, TextNode } from 'lexical';
-import { IServiceID } from "../../../types/kernel";
-export type TextFormatTransformer = Readonly<{
-    format?: ReadonlyArray<TextFormatType>;
-    intraword?: boolean;
-    process?: (selection: RangeSelection) => void;
-    tag: string;
-    type: 'text-format';
-}>;
-export type TextMatchTransformer = Readonly<{
-    /**
-     * For import operations, this function can be used to determine the end index of the match, after `importRegExp` has matched.
-     * Without this function, the end index will be determined by the length of the match from `importRegExp`. Manually determining the end index can be useful if
-     * the match from `importRegExp` is not the entire text content of the node. That way, `importRegExp` can be used to match only the start of the node, and `getEndIndex`
-     * can be used to match the end of the node.
-     *
-     * @returns The end index of the match, or false if the match was unsuccessful and a different transformer should be tried.
-     */
-    getEndIndex?: (node: TextNode, match: RegExpMatchArray) => number | false;
-    /**
-     * This regex determines what text is matched during markdown imports
-     */
-    importRegExp?: RegExp;
-    /**
-     * This regex determines what text is matched for markdown shortcuts while typing in the editor
-     */
-    regExp: RegExp;
-    /**
-     * Determines how the matched markdown text should be transformed into a node during the markdown import process
-     *
-     * @returns nothing, or a TextNode that may be a child of the new node that is created.
-     * If a TextNode is returned, text format matching will be applied to it (e.g. bold, italic, etc.)
-     */
-    replace?: (node: TextNode, match: RegExpMatchArray) => void | TextNode;
-    /**
-     * Single character that allows the transformer to trigger when typed in the editor. This does not affect markdown imports outside of the markdown shortcut plugin.
-     * If the trigger is matched, the `regExp` will be used to match the text in the second step.
-     */
-    trigger?: string;
-    type: 'text-match';
-}>;
-export type ElementTransformer = {
-    regExp: RegExp;
-    /**
-     * `replace` is called when markdown is imported or typed in the editor
-     *
-     * @return return false to cancel the transform, even though the regex matched. Lexical will then search for the next transformer.
-     */
-    replace: (parentNode: ElementNode, children: Array<LexicalNode>, match: Array<string>, 
-    /**
-     * Whether the match is from an import operation (e.g. through `$convertFromMarkdownString`) or not (e.g. through typing in the editor).
-     */
-    isImport: boolean) => boolean | void;
-    trigger?: 'enter';
-    type: 'element';
-};
-export type Transformer = ElementTransformer | TextFormatTransformer | TextMatchTransformer;
+import { ElementNode, LexicalNode, TextNode } from 'lexical';
+import type { IEditorKernel, IServiceID } from "../../../types/kernel";
+import type { MarkdownReaderFunc, TransformerRecord, TransfromerRecordArray } from '../data-source/markdown/parse';
+import type { Transformer } from './transformers';
 export interface IMarkdownWriterContext {
     /**
      * Add processor
@@ -75,7 +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: MarkdownReaderFunc<K>, level?: MARKDOWN_READER_LEVEL): void;
     registerMarkdownShortCut(transformer: Transformer): void;
     registerMarkdownShortCuts(transformers: Transformer[]): void;
     /**
@@ -93,46 +48,24 @@ export declare class MarkdownShortCutService implements IMarkdownShortCutService
     private textMatchTransformers;
     private logger;
     private _markdownWriters;
-    constructor(kernel?: import("../../../types/kernel").IEditorKernel | undefined);
-    get markdownWriters(): Record<string, (ctx: IMarkdownWriterContext, node: LexicalNode) => boolean | void>;
+    private _markdownReaders;
+    constructor(kernel?: IEditorKernel | undefined);
+    get markdownWriters(): Record<string, (_ctx: IMarkdownWriterContext, _node: LexicalNode) => boolean | void>;
+    get markdownReaders(): TransfromerRecordArray;
     private _textFormatTransformersByTrigger;
     private _textMatchTransformersByTrigger;
     get textMatchTransformersByTrigger(): Readonly<Record<string, Readonly<{
-        /**
-         * For import operations, this function can be used to determine the end index of the match, after `importRegExp` has matched.
-         * Without this function, the end index will be determined by the length of the match from `importRegExp`. Manually determining the end index can be useful if
-         * the match from `importRegExp` is not the entire text content of the node. That way, `importRegExp` can be used to match only the start of the node, and `getEndIndex`
-         * can be used to match the end of the node.
-         *
-         * @returns The end index of the match, or false if the match was unsuccessful and a different transformer should be tried.
-         */
         getEndIndex?: ((node: TextNode, match: RegExpMatchArray) => number | false) | undefined;
-        /**
-         * This regex determines what text is matched during markdown imports
-         */
         importRegExp?: RegExp | undefined;
-        /**
-         * This regex determines what text is matched for markdown shortcuts while typing in the editor
-         */
         regExp: RegExp;
-        /**
-         * Determines how the matched markdown text should be transformed into a node during the markdown import process
-         *
-         * @returns nothing, or a TextNode that may be a child of the new node that is created.
-         * If a TextNode is returned, text format matching will be applied to it (e.g. bold, italic, etc.)
-         */
         replace?: ((node: TextNode, match: RegExpMatchArray) => void | TextNode) | undefined;
-        /**
-         * Single character that allows the transformer to trigger when typed in the editor. This does not affect markdown imports outside of the markdown shortcut plugin.
-         * If the trigger is matched, the `regExp` will be used to match the text in the second step.
-         */
         trigger?: string | undefined;
         type: "text-match";
     }>[]>>;
     get textFormatTransformersByTrigger(): Readonly<Record<string, readonly Readonly<{
-        format?: readonly TextFormatType[] | undefined;
+        format?: readonly import("lexical").TextFormatType[] | undefined;
         intraword?: boolean | undefined;
-        process?: ((selection: RangeSelection) => void) | undefined;
+        process?: ((selection: import("lexical").RangeSelection) => void) | undefined;
         tag: string;
         type: "text-format";
     }>[]>>;
@@ -141,4 +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: MarkdownReaderFunc<K>, level?: MARKDOWN_READER_LEVEL): void;
 }