@lobehub/editor 4.5.0 → 4.6.0

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

@@ -1,389 +0,0 @@
-var _class;
-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 _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); }
-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 { $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 { INSERT_MARKDOWN_COMMAND, registerMarkdownCommand } from "../command";
-import MarkdownDataSource from "../data-source/markdown-data-source";
-import { IMarkdownShortCutService, MarkdownShortCutService } from "../service/shortcut";
-import { canContainTransformableMarkdown } from "../utils";
-import { detectCodeLanguage, detectLanguage } from "../utils/detectLanguage";
-var DEFAULT_PASTE_MARKDOWN_AUTO_CONVERT_THRESHOLD = 5;
-var RICH_HTML_SELECTOR = 'strong,em,b,i,h1,h2,h3,h4,h5,h6,ul,ol,table,img,blockquote,pre>code,a[href]';
-var MARKDOWN_DETECTION_RULES = [{
-  name: 'headers',
-  score: 5,
-  test: function test(text) {
-    return /^#{1,6}\s+\S/m.test(text);
-  }
-}, {
-  name: 'code-fence-start',
-  score: 5,
-  test: function test(text) {
-    return /^```[\w-]*$/m.test(text);
-  }
-}, {
-  name: 'links',
-  score: 4,
-  test: function test(text) {
-    return /\[[^\]]+]\([^)]+\)/.test(text);
-  }
-}, {
-  name: 'images',
-  score: 5,
-  test: function test(text) {
-    return /!\[[^\]]*]\([^)]+\)/.test(text);
-  }
-}, {
-  name: 'tables',
-  score: 5,
-  test: function test(text) {
-    return /^\|.+\|$/m.test(text) && /^\|[\s:|-]+\|$/m.test(text);
-  }
-}, {
-  name: 'admonitions',
-  score: 5,
-  test: function test(text) {
-    return /^>\s*\[!(?:note|tip|warning|caution|important)]/im.test(text);
-  }
-}, {
-  name: 'task-lists',
-  score: 4,
-  test: function test(text) {
-    return /^[*-]\s+\[[ x]]/m.test(text);
-  }
-}, {
-  name: 'bold',
-  score: 2,
-  test: function test(text) {
-    return /\*\*.+?\*\*/.test(text);
-  }
-}, {
-  name: 'italic',
-  score: 1,
-  test: function test(text) {
-    return /(?<!\*)\*(?!\*)(?!\s).+?(?<!\s)(?<!\*)\*(?!\*)/.test(text);
-  }
-}, {
-  name: 'unordered-lists',
-  score: 1,
-  test: function test(text) {
-    return /^[*+-]\s+\S/m.test(text);
-  }
-}, {
-  name: 'ordered-lists',
-  score: 1,
-  test: function test(text) {
-    return /^\d+\.\s+\S/m.test(text);
-  }
-}, {
-  name: 'blockquotes',
-  score: 1,
-  test: function test(text) {
-    return /^>\s+\S/m.test(text);
-  }
-}, {
-  name: 'inline-code',
-  score: 1,
-  test: function test(text) {
-    return /`.+?`/.test(text);
-  }
-}, {
-  name: 'horizontal-rules',
-  score: 2,
-  test: function test(text) {
-    return /^[*_-]{3,}$/m.test(text);
-  }
-}, {
-  name: 'multi-paragraph',
-  score: 5,
-  test: function test(text) {
-    return text.split(/\n{2,}/).filter(Boolean).length >= 2;
-  }
-}, {
-  name: 'short-text-penalty',
-  score: -3,
-  test: function test(text) {
-    return text.length < 20;
-  }
-}, {
-  name: 'single-line-penalty',
-  score: -2,
-  test: function test(text) {
-    return !text.includes('\n');
-  }
-}];
-export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
-  _inherits(MarkdownPlugin, _KernelPlugin);
-  var _super = _createSuper(MarkdownPlugin);
-  function MarkdownPlugin(kernel, config) {
-    var _this;
-    _classCallCheck(this, MarkdownPlugin);
-    _this = _super.call(this);
-    _defineProperty(_assertThisInitialized(_this), "logger", createDebugLogger('plugin', 'markdown'));
-    _defineProperty(_assertThisInitialized(_this), "service", void 0);
-    _this.kernel = kernel;
-    _this.config = config;
-    _this.service = new MarkdownShortCutService(kernel);
-    kernel.registerService(IMarkdownShortCutService, _this.service);
-    kernel.registerDataSource(new MarkdownDataSource('markdown', _this.service, function (serviceId) {
-      return kernel.requireService(serviceId);
-    }));
-    return _this;
-  }
-  _createClass(MarkdownPlugin, [{
-    key: "onInit",
-    value: function onInit(editor) {
-      var _this2 = this;
-      this.register(editor.registerUpdateListener(function (_ref) {
-        var tags = _ref.tags,
-          dirtyLeaves = _ref.dirtyLeaves,
-          editorState = _ref.editorState,
-          prevEditorState = _ref.prevEditorState;
-        // Ignore updates from collaboration and undo/redo (as changes already calculated)
-        if (tags.has(COLLABORATION_TAG) || tags.has(HISTORIC_TAG)) {
-          return;
-        }
-
-        // If editor is still composing (i.e. backticks) we must wait before the user confirms the key
-        if (editor.isComposing()) {
-          return;
-        }
-        var selection = editorState.read($getSelection);
-        var prevSelection = prevEditorState.read($getSelection);
-
-        // We expect selection to be a collapsed range and not match previous one (as we want
-        // to trigger transforms only as user types)
-        if (!$isRangeSelection(prevSelection) || !$isRangeSelection(selection) || !selection.isCollapsed() || selection.is(prevSelection)) {
-          return;
-        }
-        var anchorKey = selection.anchor.key;
-        var anchorOffset = selection.anchor.offset;
-        var anchorNode = editorState._nodeMap.get(anchorKey);
-        if (!$isTextNode(anchorNode) || !dirtyLeaves.has(anchorKey) || anchorOffset !== 1 && anchorOffset > prevSelection.anchor.offset + 1) {
-          return;
-        }
-        editor.update(function () {
-          if (!canContainTransformableMarkdown(anchorNode)) {
-            return;
-          }
-          var parentNode = anchorNode.getParent();
-          if (parentNode === null || $isCodeNode(parentNode)) {
-            return;
-          }
-          _this2.service.runTransformers(parentNode, anchorNode, selection.anchor.offset);
-        });
-      }));
-      this.register(editor.registerCommand(KEY_ENTER_COMMAND, function (payload) {
-        var ret = editor.getEditorState().read(function () {
-          var selection = $getSelection();
-          if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
-            return false;
-          }
-          var anchorKey = selection.anchor.key;
-          var anchorNode = $getNodeByKey(anchorKey);
-          if (!anchorNode) return false;
-          return {
-            anchorNode: anchorNode,
-            offset: selection.anchor.offset
-          };
-        });
-        if (!ret) return false;
-        var anchorNode = ret.anchorNode,
-          offset = ret.offset;
-        if (!canContainTransformableMarkdown(anchorNode)) {
-          return false;
-        }
-        var parentNode = anchorNode.getParent();
-        if (parentNode === null || $isCodeNode(parentNode)) {
-          return false;
-        }
-        if (_this2.service.testTransformers(parentNode, anchorNode, offset, 'enter')) {
-          queueMicrotask(function () {
-            editor.update(function () {
-              _this2.service.runTransformers(parentNode, anchorNode, offset, 'enter');
-            });
-          });
-          payload === null || payload === void 0 || payload.stopPropagation();
-          payload === null || payload === void 0 || payload.stopImmediatePropagation();
-          payload === null || payload === void 0 || payload.preventDefault();
-          return true;
-        }
-        return false;
-      }, COMMAND_PRIORITY_CRITICAL));
-      this.register(editor.registerCommand(PASTE_COMMAND, function (event) {
-        if (!(event instanceof ClipboardEvent)) return false;
-        if (!_this2.shouldHandlePasteMarkdown()) return false;
-        var clipboardData = event.clipboardData;
-        if (!clipboardData) return false;
-
-        // Get clipboard content and clean BOM/zero-width characters
-        var rawText = clipboardData.getData('text/plain').trimEnd();
-        // Remove BOM, zero-width spaces, and other invisible characters
-        var text = rawText.replaceAll(/[\u200B-\u200D\u2060\uFEFF]/g, '');
-        var html = clipboardData.getData('text/html').trimEnd();
-
-        // If there's no text content, let Lexical handle it
-        if (!text) return false;
-        _this2.logger.debug('paste content analysis:', {
-          clipboardTypes: Array.from(clipboardData.types || []),
-          hasHTML: !!(html && html.trim()),
-          htmlLength: (html === null || html === void 0 ? void 0 : html.length) || 0,
-          textLength: text.length
-        });
-        if (_this2.hasRichHTML(clipboardData)) {
-          _this2.logger.debug('rich HTML detected, skipping markdown auto-convert');
-          return false;
-        }
-        var detectionResult = _this2.getMarkdownDetectionResult(text);
-        if (detectionResult.shouldAutoConvert) {
-          _this2.logger.debug('markdown auto-convert detected:', detectionResult);
-          var historyState = _this2.kernel.getHistoryState().current;
-          setTimeout(function () {
-            editor.dispatchCommand(INSERT_MARKDOWN_COMMAND, {
-              historyState: historyState,
-              markdown: text
-            });
-            _this2.kernel.emit('markdownParse', {
-              cacheState: editor.getEditorState(),
-              historyState: historyState,
-              markdown: text,
-              matchedPatterns: detectionResult.matchedPatterns,
-              score: detectionResult.score
-            });
-          }, 10);
-        } else {
-          _this2.logger.debug('markdown score below auto-convert threshold, keeping as plain text:', detectionResult);
-        }
-        return false;
-      }, COMMAND_PRIORITY_CRITICAL));
-      this.register(registerMarkdownCommand(editor, this.kernel, this.service));
-    }
-
-    /**
-     * Detect if content is code and should be inserted as code block
-     * Uses advanced language detection with pattern matching
-     * Excludes markdown because markdown content is handled by the paste auto-convert flow
-     */
-  }, {
-    key: "detectCodeContent",
-    value: function detectCodeContent(text) {
-      // Use the advanced language detector
-      var detected = detectLanguage(text);
-      if (detected && detected.confidence > 50) {
-        // Don't insert markdown as code block - it should use the markdown auto-convert flow
-        if (detected.language === 'markdown') {
-          return null;
-        }
-        this.logger.debug('language detected:', detected);
-        return detected;
-      }
-
-      // Fallback to fast detection for common formats
-      var fastDetected = detectCodeLanguage(text);
-      if (fastDetected) {
-        // Don't insert markdown as code block
-        if (fastDetected === 'markdown') {
-          return null;
-        }
-        return {
-          confidence: 80,
-          language: fastDetected
-        };
-      }
-      return null;
-    }
-  }, {
-    key: "hasRichHTML",
-    value: function hasRichHTML(clipboardData) {
-      var html = clipboardData.getData('text/html');
-      if (!html) return false;
-      if (/data-vscode|vscode-/i.test(html)) return false;
-      if (typeof DOMParser === 'undefined') return false;
-      var doc = new DOMParser().parseFromString(html, 'text/html');
-      var richTags = doc.body.querySelectorAll(RICH_HTML_SELECTOR);
-      return richTags.length > 0;
-    }
-
-    /**
-     * Analyze pasted text and determine whether it should auto convert to markdown
-     */
-  }, {
-    key: "getMarkdownDetectionResult",
-    value: function getMarkdownDetectionResult(text) {
-      if (this.detectCodeContent(text)) {
-        return {
-          matchedPatterns: [],
-          score: 0,
-          shouldAutoConvert: false
-        };
-      }
-      var matchedPatterns = [];
-      var score = 0;
-      var threshold = this.getPasteMarkdownAutoConvertThreshold();
-      for (var _i = 0, _MARKDOWN_DETECTION_R = MARKDOWN_DETECTION_RULES; _i < _MARKDOWN_DETECTION_R.length; _i++) {
-        var rule = _MARKDOWN_DETECTION_R[_i];
-        if (!rule.test(text)) continue;
-        matchedPatterns.push(rule.name);
-        score += rule.score;
-      }
-      return {
-        matchedPatterns: matchedPatterns,
-        score: score,
-        shouldAutoConvert: score >= threshold
-      };
-    }
-  }, {
-    key: "getPasteMarkdownAutoConvertThreshold",
-    value: function getPasteMarkdownAutoConvertThreshold() {
-      var _this$config;
-      var threshold = (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.pasteMarkdownAutoConvertThreshold;
-      if (typeof threshold !== 'number' || Number.isNaN(threshold)) {
-        return DEFAULT_PASTE_MARKDOWN_AUTO_CONVERT_THRESHOLD;
-      }
-      return Math.max(1, threshold);
-    }
-  }, {
-    key: "shouldHandlePasteMarkdown",
-    value: function shouldHandlePasteMarkdown() {
-      var _this$config2, _this$config3;
-      if (((_this$config2 = this.config) === null || _this$config2 === void 0 ? void 0 : _this$config2.enablePasteMarkdown) === false) {
-        return false;
-      }
-      return ((_this$config3 = this.config) === null || _this$config3 === void 0 ? void 0 : _this$config3.autoFormatMarkdown) !== 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

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

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

@@ -1,38 +0,0 @@
-'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 { toast } from '@lobehub/ui';
-import { useLayoutEffect } from 'react';
-import { useLexicalComposerContext } from "../../../editor-kernel/react";
-import { useTranslation } from "../../../editor-kernel/react/useTranslation";
-import { INodePlugin } from "../../inode";
-import { MarkdownPlugin } from "../plugin";
-var ReactMarkdownPlugin = function ReactMarkdownPlugin() {
-  var _useLexicalComposerCo = useLexicalComposerContext(),
-    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
-    editor = _useLexicalComposerCo2[0];
-  var t = useTranslation();
-  useLayoutEffect(function () {
-    editor.registerPlugin(INodePlugin);
-    editor.registerPlugin(MarkdownPlugin);
-    var handleEvent = function handleEvent() {
-      toast.info({
-        description: t('markdown.autoFormatMessage'),
-        duration: 5000,
-        title: t('markdown.autoFormatTitle')
-      });
-    };
-    editor.on('markdownParse', handleEvent);
-    return function () {
-      editor.off('markdownParse', handleEvent);
-    };
-  }, [editor, t]);
-  return null;
-};
-ReactMarkdownPlugin.displayName = 'ReactMarkdownPlugin';
-export default ReactMarkdownPlugin;

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

@@ -1,90 +0,0 @@
-import { BaseSelection, ElementNode, LexicalEditor, LexicalNode, TextNode } from 'lexical';
-import { IRootNode } from "../../../editor-kernel/inode";
-import type { IEditorKernel, IServiceID } from "../../../types/kernel";
-import { type MarkdownReaderFunc, type TransformerRecord, type TransfromerRecordArray } from '../data-source/markdown/parse';
-import type { Transformer } from './transformers';
-export interface IMarkdownWriterContext {
-    /**
-     * Add processor
-     * @param processor
-     */
-    addProcessor(processor: (before: string, content: string, after: string) => string): void;
-    /**
-     * Direct output
-     * @param line
-     * @returns
-     */
-    appendLine: (line: string) => void;
-    /**
-     * Control child node to markdown
-     * @param parentCtx
-     * @param child
-     * @returns
-     */
-    processChild: (parentCtx: IMarkdownWriterContext, child: LexicalNode) => void;
-    /**
-     * Wrap child elements
-     * @param before
-     * @param after
-     * @returns
-     */
-    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 {
-    insertIRootNode(editor: LexicalEditor, root: IRootNode, selection: BaseSelection): void;
-    parseMarkdownToLexical(markdown: string): IRootNode;
-    /**
-     * 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;
-    /**
-     * Register Markdown writer
-     * @param type Lexical Node type
-     * @param writer
-     */
-    registerMarkdownWriter(type: string, writer: (ctx: IMarkdownWriterContext, node: LexicalNode) => void | boolean): void;
-}
-export declare const IMarkdownShortCutService: IServiceID<IMarkdownShortCutService>;
-export declare class MarkdownShortCutService implements IMarkdownShortCutService {
-    private kernel?;
-    private elementTransformers;
-    private textFormatTransformers;
-    private textMatchTransformers;
-    private logger;
-    private _markdownWriters;
-    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<{
-        getEndIndex?: ((node: TextNode, match: RegExpMatchArray) => number | false) | undefined;
-        importRegExp?: RegExp | undefined;
-        regExp: RegExp;
-        replace?: ((node: TextNode, match: RegExpMatchArray) => void | TextNode) | undefined;
-        trigger?: string | undefined;
-        type: "text-match";
-    }>[]>>;
-    get textFormatTransformersByTrigger(): Readonly<Record<string, readonly Readonly<{
-        format?: readonly import("lexical").TextFormatType[] | undefined;
-        intraword?: boolean | undefined;
-        process?: ((selection: import("lexical").RangeSelection) => boolean | void) | undefined;
-        tag: string;
-        type: "text-format";
-    }>[]>>;
-    registerMarkdownShortCut(transformer: Transformer): void;
-    registerMarkdownShortCuts(transformers: Transformer[]): void;
-    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;
-    parseMarkdownToLexical(markdown: string): IRootNode;
-    insertIRootNode(editor: LexicalEditor, root: IRootNode, selection: BaseSelection): void;
-}