@lobehub/editor 1.0.0

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

@@ -0,0 +1,139 @@
+import { ElementNode, LexicalNode, TextFormatType, TextNode } from 'lexical';
+import { IServiceID } from "../../../editor-kernel/types";
+export type TextFormatTransformer = Readonly<{
+    format: ReadonlyArray<TextFormatType>;
+    intraword?: boolean;
+    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;
+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;
+    /**
+     * Wrap child elements
+     * @param before
+     * @param after
+     * @returns
+     */
+    wrap: (before: string, after: string) => void;
+}
+export interface IMarkdownShortCutService {
+    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): void;
+}
+export declare const IMarkdownShortCutService: IServiceID<IMarkdownShortCutService>;
+export declare class MarkdownShortCutService implements IMarkdownShortCutService {
+    private elementTransformers;
+    private textFormatTransformers;
+    private textMatchTransformers;
+    private _markdownWriters;
+    get markdownWriters(): Record<string, (ctx: IMarkdownWriterContext, node: LexicalNode) => void>;
+    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[];
+        intraword?: boolean | 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) => void): void;
+}

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

@@ -0,0 +1,401 @@
+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 _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); }
+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 _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 _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; }
+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; }
+/* eslint-disable no-redeclare */
+/* eslint-disable @typescript-eslint/no-redeclare */
+import { $createRangeSelection, $getSelection, $isLineBreakNode, $isRangeSelection, $isRootOrShadowRoot, $isTextNode, $setSelection } from 'lexical';
+import { genServiceId } from "../../../editor-kernel";
+import { PUNCTUATION_OR_SPACE, getOpenTagStartIndex, indexBy, isEqualSubString } from "../utils";
+export var IMarkdownShortCutService = genServiceId('MarkdownShortCutService');
+function testElementTransformers(parentNode, anchorNode, anchorOffset, elementTransformers, fromTrigger) {
+  var grandParentNode = parentNode.getParent();
+  if (!$isRootOrShadowRoot(grandParentNode) || parentNode.getFirstChild() !== anchorNode) {
+    return false;
+  }
+  var textContent = anchorNode.getTextContent();
+
+  // Checking for anchorOffset position to prevent any checks for cases when caret is too far
+  // from a line start to be a part of block-level markdown trigger.
+  //
+  // TODO:
+  // Can have a quick check if caret is close enough to the beginning of the string (e.g. offset less than 10-20)
+  // since otherwise it won't be a markdown shortcut, but tables are exception
+  if (fromTrigger !== 'enter' && textContent[anchorOffset - 1] !== ' ') {
+    return false;
+  }
+  var _iterator = _createForOfIteratorHelper(elementTransformers),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _step.value,
+        regExp = _step$value.regExp,
+        trigger = _step$value.trigger;
+      var _match = textContent.match(regExp);
+      if (fromTrigger === trigger && _match && _match[0].length === (fromTrigger === 'enter' || _match[0].endsWith(' ') ? anchorOffset : anchorOffset - 1)) {
+        return true;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return false;
+}
+function runElementTransformers(parentNode, anchorNode, anchorOffset, elementTransformers, fromTrigger) {
+  var grandParentNode = parentNode.getParent();
+  if (!$isRootOrShadowRoot(grandParentNode) || parentNode.getFirstChild() !== anchorNode) {
+    return false;
+  }
+  var textContent = anchorNode.getTextContent();
+
+  // Checking for anchorOffset position to prevent any checks for cases when caret is too far
+  // from a line start to be a part of block-level markdown trigger.
+  //
+  // TODO:
+  // Can have a quick check if caret is close enough to the beginning of the string (e.g. offset less than 10-20)
+  // since otherwise it won't be a markdown shortcut, but tables are exception
+  if (fromTrigger !== 'enter' && textContent[anchorOffset - 1] !== ' ') {
+    return false;
+  }
+  var _iterator2 = _createForOfIteratorHelper(elementTransformers),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _step2$value = _step2.value,
+        regExp = _step2$value.regExp,
+        replace = _step2$value.replace,
+        trigger = _step2$value.trigger;
+      var _match2 = textContent.match(regExp);
+      if (fromTrigger === trigger && _match2 && _match2[0].length === (fromTrigger === 'enter' || _match2[0].endsWith(' ') ? anchorOffset : anchorOffset - 1)) {
+        var nextSiblings = anchorNode.getNextSiblings();
+        var _anchorNode$splitText = anchorNode.splitText(anchorOffset),
+          _anchorNode$splitText2 = _slicedToArray(_anchorNode$splitText, 2),
+          leadingNode = _anchorNode$splitText2[0],
+          remainderNode = _anchorNode$splitText2[1];
+        var siblings = remainderNode ? [remainderNode].concat(_toConsumableArray(nextSiblings)) : nextSiblings;
+        if (replace(parentNode, siblings, _match2, false) !== false) {
+          leadingNode.remove();
+          return true;
+        }
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return false;
+}
+function runTextMatchTransformers(anchorNode, anchorOffset, transformersByTrigger) {
+  var textContent = anchorNode.getTextContent();
+  var lastChar = textContent[anchorOffset - 1];
+  var transformers = transformersByTrigger[lastChar];
+  if (!transformers) {
+    return false;
+  }
+
+  // If typing in the middle of content, remove the tail to do
+  // reg exp match up to a string end (caret position)
+  if (anchorOffset < textContent.length) {
+    textContent = textContent.slice(0, anchorOffset);
+  }
+  var _iterator3 = _createForOfIteratorHelper(transformers),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _transformer = _step3.value;
+      if (!_transformer.replace || !_transformer.regExp) {
+        continue;
+      }
+      var _match3 = textContent.match(_transformer.regExp);
+      if (_match3 === null) {
+        continue;
+      }
+      var startIndex = _match3.index || 0;
+      var endIndex = startIndex + _match3[0].length;
+      var replaceNode = void 0;
+      if (startIndex === 0) {
+        var _anchorNode$splitText3 = anchorNode.splitText(endIndex);
+        var _anchorNode$splitText4 = _slicedToArray(_anchorNode$splitText3, 1);
+        replaceNode = _anchorNode$splitText4[0];
+      } else {
+        var _anchorNode$splitText5 = anchorNode.splitText(startIndex, endIndex);
+        var _anchorNode$splitText6 = _slicedToArray(_anchorNode$splitText5, 2);
+        replaceNode = _anchorNode$splitText6[1];
+      }
+      replaceNode.selectNext(0, 0);
+      _transformer.replace(replaceNode, _match3);
+      return true;
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return false;
+}
+function $runTextFormatTransformers(anchorNode, anchorOffset, textFormatTransformers) {
+  var textContent = anchorNode.getTextContent();
+  var closeTagEndIndex = anchorOffset - 1;
+  var closeChar = textContent[closeTagEndIndex];
+  // Quick check if we're possibly at the end of inline markdown style
+  var matchers = textFormatTransformers[closeChar];
+  if (!matchers) {
+    return false;
+  }
+  var _iterator4 = _createForOfIteratorHelper(matchers),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var matcher = _step4.value;
+      var tag = matcher.tag;
+      var tagLength = tag.length;
+      var closeTagStartIndex = closeTagEndIndex - tagLength + 1;
+
+      // If tag is not single char check if rest of it matches with text content
+      if (tagLength > 1 && !isEqualSubString(textContent, closeTagStartIndex, tag, 0, tagLength)) {
+        continue;
+      }
+
+      // Space before closing tag cancels inline markdown
+      if (textContent[closeTagStartIndex - 1] === ' ') {
+        continue;
+      }
+
+      // Some tags can not be used within words, hence should have newline/space/punctuation after it
+      var afterCloseTagChar = textContent[closeTagEndIndex + 1];
+      if (matcher.intraword === false && afterCloseTagChar && !PUNCTUATION_OR_SPACE.test(afterCloseTagChar)) {
+        continue;
+      }
+      var closeNode = anchorNode;
+      var openNode = closeNode;
+      var openTagStartIndex = getOpenTagStartIndex(textContent, closeTagStartIndex, tag);
+
+      // Go through text node siblings and search for opening tag
+      // if haven't found it within the same text node as closing tag
+      var sibling = openNode;
+      while (openTagStartIndex < 0 && (sibling = sibling.getPreviousSibling())) {
+        if ($isLineBreakNode(sibling)) {
+          break;
+        }
+        if ($isTextNode(sibling)) {
+          if (sibling.hasFormat('code')) {
+            continue;
+          }
+          var siblingTextContent = sibling.getTextContent();
+          openNode = sibling;
+          openTagStartIndex = getOpenTagStartIndex(siblingTextContent, siblingTextContent.length, tag);
+        }
+      }
+
+      // Opening tag is not found
+      if (openTagStartIndex < 0) {
+        continue;
+      }
+
+      // No content between opening and closing tag
+      if (openNode === closeNode && openTagStartIndex + tagLength === closeTagStartIndex) {
+        continue;
+      }
+
+      // Checking longer tags for repeating chars (e.g. *** vs **)
+      var prevOpenNodeText = openNode.getTextContent();
+      if (openTagStartIndex > 0 && prevOpenNodeText[openTagStartIndex - 1] === closeChar) {
+        continue;
+      }
+
+      // Some tags can not be used within words, hence should have newline/space/punctuation before it
+      var beforeOpenTagChar = prevOpenNodeText[openTagStartIndex - 1];
+      if (matcher.intraword === false && beforeOpenTagChar && !PUNCTUATION_OR_SPACE.test(beforeOpenTagChar)) {
+        continue;
+      }
+
+      // Clean text from opening and closing tags (starting from closing tag
+      // to prevent any offset shifts if we start from opening one)
+      var prevCloseNodeText = closeNode.getTextContent();
+      var closeNodeText = prevCloseNodeText.slice(0, closeTagStartIndex) + prevCloseNodeText.slice(closeTagEndIndex + 1);
+      closeNode.setTextContent(closeNodeText);
+      var openNodeText = openNode === closeNode ? closeNodeText : prevOpenNodeText;
+      openNode.setTextContent(openNodeText.slice(0, openTagStartIndex) + openNodeText.slice(openTagStartIndex + tagLength));
+      var selection = $getSelection();
+      var nextSelection = $createRangeSelection();
+      $setSelection(nextSelection);
+      // Adjust offset based on deleted chars
+      var newOffset = closeTagEndIndex - tagLength * (openNode === closeNode ? 2 : 1) + 1;
+      nextSelection.anchor.set(openNode.__key, openTagStartIndex, 'text');
+      nextSelection.focus.set(closeNode.__key, newOffset, 'text');
+
+      // Apply formatting to selected text
+      var _iterator5 = _createForOfIteratorHelper(matcher.format),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var format = _step5.value;
+          if (!nextSelection.hasFormat(format)) {
+            nextSelection.formatText(format);
+          }
+        }
+
+        // Collapse selection up to the focus point
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+      nextSelection.anchor.set(nextSelection.focus.key, nextSelection.focus.offset, nextSelection.focus.type);
+
+      // Remove formatting from collapsed selection
+      var _iterator6 = _createForOfIteratorHelper(matcher.format),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var _format = _step6.value;
+          if (nextSelection.hasFormat(_format)) {
+            nextSelection.toggleFormat(_format);
+          }
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+      if ($isRangeSelection(selection)) {
+        nextSelection.format = selection.format;
+      }
+      return true;
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  return false;
+}
+export var MarkdownShortCutService = /*#__PURE__*/function () {
+  function MarkdownShortCutService() {
+    _classCallCheck(this, MarkdownShortCutService);
+    _defineProperty(this, "elementTransformers", []);
+    _defineProperty(this, "textFormatTransformers", []);
+    _defineProperty(this, "textMatchTransformers", []);
+    _defineProperty(this, "_markdownWriters", {});
+    _defineProperty(this, "_textFormatTransformersByTrigger", null);
+    _defineProperty(this, "_textMatchTransformersByTrigger", null);
+  }
+  _createClass(MarkdownShortCutService, [{
+    key: "markdownWriters",
+    get: function get() {
+      return this._markdownWriters;
+    }
+  }, {
+    key: "textMatchTransformersByTrigger",
+    get: function get() {
+      if (!this._textMatchTransformersByTrigger) {
+        this._textMatchTransformersByTrigger = indexBy(this.textMatchTransformers, function (_ref) {
+          var trigger = _ref.trigger;
+          return trigger;
+        });
+      }
+      return this._textMatchTransformersByTrigger;
+    }
+  }, {
+    key: "textFormatTransformersByTrigger",
+    get: function get() {
+      if (!this._textFormatTransformersByTrigger) {
+        this._textFormatTransformersByTrigger = indexBy(this.textFormatTransformers, function (_ref2) {
+          var tag = _ref2.tag;
+          return tag.at(-1);
+        });
+      }
+      return this._textFormatTransformersByTrigger;
+    }
+  }, {
+    key: "registerMarkdownShortCut",
+    value: function registerMarkdownShortCut(transformer) {
+      switch (transformer.type) {
+        case 'element':
+          {
+            this.elementTransformers.push(transformer);
+            break;
+          }
+        case 'text-format':
+          {
+            this.textFormatTransformers.push(transformer);
+            break;
+          }
+        case 'text-match':
+          {
+            this.textMatchTransformers.push(transformer);
+            break;
+          }
+        default:
+          {
+            throw new Error("Unknown transformer type: ".concat(transformer));
+          }
+      }
+    }
+  }, {
+    key: "registerMarkdownShortCuts",
+    value: function registerMarkdownShortCuts(transformers) {
+      var _iterator7 = _createForOfIteratorHelper(transformers),
+        _step7;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var _transformer2 = _step7.value;
+          this.registerMarkdownShortCut(_transformer2);
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+    }
+  }, {
+    key: "testTransformers",
+    value: function testTransformers(parentNode, anchorNode, anchorOffset, trigger) {
+      if (testElementTransformers(parentNode, anchorNode, anchorOffset, this.elementTransformers, trigger)) {
+        return true;
+      }
+      return false;
+    }
+  }, {
+    key: "runTransformers",
+    value: function runTransformers(parentNode, anchorNode, anchorOffset, trigger) {
+      if (runElementTransformers(parentNode, anchorNode, anchorOffset, this.elementTransformers, trigger)) {
+        return true;
+      }
+      if (runTextMatchTransformers(anchorNode, anchorOffset, this.textMatchTransformersByTrigger)) {
+        return true;
+      }
+      if ($runTextFormatTransformers(anchorNode, anchorOffset, this.textFormatTransformersByTrigger)) {
+        return true;
+      }
+      return false;
+    }
+  }, {
+    key: "registerMarkdownWriter",
+    value: function registerMarkdownWriter(type, writer) {
+      if (!this._markdownWriters[type]) {
+        this._markdownWriters[type] = writer;
+        return;
+      }
+      throw new Error("Markdown writer for type \"".concat(type, "\" is already registered."));
+    }
+  }]);
+  return MarkdownShortCutService;
+}();

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

@@ -0,0 +1,12 @@
+import { LexicalNode, TextNode } from 'lexical';
+/**
+ * Returns true if the node can contain transformable markdown.
+ * Code nodes cannot contain transformable markdown.
+ * For example, `code **bold**` should not be transformed to
+ * <code>code <strong>bold</strong></code>.
+ */
+export declare function canContainTransformableMarkdown(node: LexicalNode | undefined): node is TextNode;
+export declare function isEqualSubString(stringA: string, aStart: number, stringB: string, bStart: number, length: number): boolean;
+export declare const PUNCTUATION_OR_SPACE: RegExp;
+export declare function getOpenTagStartIndex(string: string, maxIndex: number, tag: string): number;
+export declare function indexBy<T>(list: Array<T>, callback: (arg0: T) => string | undefined): Readonly<Record<string, Array<T>>>;

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

@@ -0,0 +1,61 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import { $isTextNode } from 'lexical';
+
+/**
+ * Returns true if the node can contain transformable markdown.
+ * Code nodes cannot contain transformable markdown.
+ * For example, `code **bold**` should not be transformed to
+ * <code>code <strong>bold</strong></code>.
+ */
+export function canContainTransformableMarkdown(node) {
+  return $isTextNode(node) && !node.hasFormat('code');
+}
+export function isEqualSubString(stringA, aStart, stringB, bStart, length) {
+  for (var i = 0; i < length; i++) {
+    if (stringA[aStart + i] !== stringB[bStart + i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// eslint-disable-next-line unicorn/better-regex
+export var PUNCTUATION_OR_SPACE = /[!-/:-@[-`{-~\s]/;
+export function getOpenTagStartIndex(string, maxIndex, tag) {
+  var tagLength = tag.length;
+  for (var i = maxIndex; i >= tagLength; i--) {
+    var startIndex = i - tagLength;
+    if (isEqualSubString(string, startIndex, tag, 0, tagLength) &&
+    // Space after opening tag cancels transformation
+    string[startIndex + tagLength] !== ' ') {
+      return startIndex;
+    }
+  }
+  return -1;
+}
+export function indexBy(list, callback) {
+  var index = {};
+  var _iterator = _createForOfIteratorHelper(list),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      var key = callback(item);
+      if (!key) {
+        continue;
+      }
+      if (index[key]) {
+        index[key].push(item);
+      } else {
+        index[key] = [item];
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return index;
+}

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

@@ -0,0 +1,6 @@
+import { LexicalEditor } from 'lexical';
+export declare const INSERT_MENTION_COMMAND: import("lexical").LexicalCommand<{
+    extra?: Record<string, unknown> | undefined;
+    label: string;
+}>;
+export declare function registerMentionCommand(editor: LexicalEditor): () => void;

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

@@ -0,0 +1,19 @@
+import { $wrapNodeInElement } from '@lexical/utils';
+import { $createParagraphNode, $insertNodes, $isRootOrShadowRoot, COMMAND_PRIORITY_HIGH, createCommand } from 'lexical';
+import { $createMentionNode } from "../node/MentionNode";
+export var INSERT_MENTION_COMMAND = createCommand('INSERT_MENTION_COMMAND');
+export function registerMentionCommand(editor) {
+  return editor.registerCommand(INSERT_MENTION_COMMAND, function (payload) {
+    var extra = payload.extra,
+      label = payload.label;
+    editor.update(function () {
+      var mentionNode = $createMentionNode(label, extra);
+      $insertNodes([mentionNode]); // Insert a zero-width space to ensure the image is not the last child
+      if ($isRootOrShadowRoot(mentionNode.getParentOrThrow())) {
+        $wrapNodeInElement(mentionNode, $createParagraphNode).selectEnd();
+      }
+    });
+    return true;
+  }, COMMAND_PRIORITY_HIGH // Priority
+  );
+}

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

@@ -0,0 +1,3 @@
+export { INSERT_MENTION_COMMAND } from './command';
+export * from './plugin';
+export * from './react';

package/es/plugins/mention/index.js

@@ -0,0 +1,3 @@
+export { INSERT_MENTION_COMMAND } from "./command";
+export * from "./plugin";
+export * from "./react";