@lobehub/editor 1.11.0 → 1.12.0

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

@@ -0,0 +1,286 @@
+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; }
+import { $createRangeSelection, $getSelection, $isLineBreakNode, $isRangeSelection, $isRootOrShadowRoot, $isTextNode, $setSelection } from 'lexical';
+import { PUNCTUATION_OR_SPACE, getOpenTagStartIndex, isEqualSubString } from "../utils";
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export 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');
+      if (matcher.process) {
+        matcher.process(nextSelection);
+        return true;
+      } else if (matcher.format) {
+        // 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;
+        }
+      } else {
+        // No format or process specified, nothing to do
+        $setSelection(_selection);
+        continue;
+      }
+      return true;
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  return false;
+}

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

@@ -1,4 +1,4 @@
-import { LexicalNode, TextNode } from 'lexical';
+import { BaseSelection, LexicalEditor, LexicalNode, TextNode } from 'lexical';
 /**
  * Returns true if the node can contain transformable markdown.
  * Code nodes cannot contain transformable markdown.
@@ -16,3 +16,47 @@ export declare function indexBy<T>(list: Array<T>, callback: (arg0: T) => string
  * @returns True if the character is a punctuation character, false otherwise.
  */
 export declare function isPunctuationChar(char: string): boolean;
+/**
+ * Inserts Lexical nodes into the editor using different strategies depending on
+ * some simple selection-based heuristics. If you're looking for a generic way to
+ * to insert nodes into the editor at a specific selection point, you probably want
+ * {@link lexical.$insertNodes}
+ *
+ * @param editor LexicalEditor instance to insert the nodes into.
+ * @param nodes The nodes to insert.
+ * @param selection The selection to insert the nodes into.
+ */
+export declare function $insertGeneratedNodes(editor: LexicalEditor, nodes: Array<LexicalNode>, selection: BaseSelection): void;
+export interface BaseSerializedNode {
+    children?: Array<BaseSerializedNode>;
+    type: string;
+    version: number;
+}
+/**
+ * Creates an object containing all the styles and their values provided in the CSS string.
+ * @param css - The CSS string of styles and their values.
+ * @returns The styleObject containing all the styles and their values.
+ */
+export declare function getStyleObjectFromRawCSS(css: string): Record<string, string>;
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export declare const CSS_TO_STYLES: Map<string, Record<string, string>>;
+/**
+ * Gets the TextNode's style object and adds the styles to the CSS.
+ * @param node - The TextNode to add styles to.
+ */
+export declare function $addNodeStyle(node: TextNode): void;
+/**
+ * This method takes an array of objects conforming to the BaseSerializedNode interface and returns
+ * an Array containing instances of the corresponding LexicalNode classes registered on the editor.
+ * Normally, you'd get an Array of BaseSerialized nodes from {@link $generateJSONFromSelectedNodes}
+ *
+ * @param serializedNodes an Array of objects conforming to the BaseSerializedNode interface.
+ * @returns an Array of Lexical Node objects.
+ */
+export declare function $generateNodesFromSerializedNodes(serializedNodes: Array<BaseSerializedNode>): Array<LexicalNode>;

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

@@ -1,7 +1,11 @@
+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; }
-import { $isTextNode } from 'lexical';
+import { $caretFromPoint, $getCaretRange, $getChildCaret, $getRoot, $isElementNode, $isRangeSelection, $isTextNode, $isTextPointCaret, $parseSerializedNode, SELECTION_INSERT_CLIPBOARD_NODES_COMMAND } from 'lexical';
 
 /**
  * Returns true if the node can contain transformable markdown.
@@ -71,4 +75,146 @@ try {
  */
 export function isPunctuationChar(char) {
   return Punctuation.test(char);
+}
+function $updateSelectionOnInsert(selection) {
+  if ($isRangeSelection(selection) && selection.isCollapsed()) {
+    var anchor = selection.anchor;
+    var nodeToInspect = null;
+    var anchorCaret = $caretFromPoint(anchor, 'previous');
+    if (anchorCaret) {
+      if ($isTextPointCaret(anchorCaret)) {
+        nodeToInspect = anchorCaret.origin;
+      } else {
+        var range = $getCaretRange(anchorCaret, $getChildCaret($getRoot(), 'next').getFlipped());
+        var _iterator2 = _createForOfIteratorHelper(range),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var caret = _step2.value;
+            if ($isTextNode(caret.origin)) {
+              nodeToInspect = caret.origin;
+              break;
+            } else if ($isElementNode(caret.origin) && !caret.origin.isInline()) {
+              break;
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      }
+    }
+    if (nodeToInspect && $isTextNode(nodeToInspect)) {
+      var newFormat = nodeToInspect.getFormat();
+      var newStyle = nodeToInspect.getStyle();
+      if (selection.format !== newFormat || selection.style !== newStyle) {
+        selection.format = newFormat;
+        selection.style = newStyle;
+        selection.dirty = true;
+      }
+    }
+  }
+}
+
+/**
+ * Inserts Lexical nodes into the editor using different strategies depending on
+ * some simple selection-based heuristics. If you're looking for a generic way to
+ * to insert nodes into the editor at a specific selection point, you probably want
+ * {@link lexical.$insertNodes}
+ *
+ * @param editor LexicalEditor instance to insert the nodes into.
+ * @param nodes The nodes to insert.
+ * @param selection The selection to insert the nodes into.
+ */
+export function $insertGeneratedNodes(editor, nodes, selection) {
+  if (!editor.dispatchCommand(SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, {
+    nodes: nodes,
+    selection: selection
+  })) {
+    selection.insertNodes(nodes);
+    $updateSelectionOnInsert(selection);
+  }
+  return;
+}
+/**
+ * Creates an object containing all the styles and their values provided in the CSS string.
+ * @param css - The CSS string of styles and their values.
+ * @returns The styleObject containing all the styles and their values.
+ */
+export function getStyleObjectFromRawCSS(css) {
+  var styleObject = {};
+  if (!css) {
+    return styleObject;
+  }
+  var styles = css.split(';');
+  var _iterator3 = _createForOfIteratorHelper(styles),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var style = _step3.value;
+      if (style !== '') {
+        var _style$split = style.split(/:([^]+)/),
+          _style$split2 = _slicedToArray(_style$split, 2),
+          key = _style$split2[0],
+          value = _style$split2[1]; // split on first colon
+        if (key && value) {
+          styleObject[key.trim()] = value.trim();
+        }
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return styleObject;
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export var CSS_TO_STYLES = new Map();
+
+/**
+ * Gets the TextNode's style object and adds the styles to the CSS.
+ * @param node - The TextNode to add styles to.
+ */
+export function $addNodeStyle(node) {
+  var CSSText = node.getStyle();
+  var styles = getStyleObjectFromRawCSS(CSSText);
+  CSS_TO_STYLES.set(CSSText, styles);
+}
+
+/**
+ * This method takes an array of objects conforming to the BaseSerializedNode interface and returns
+ * an Array containing instances of the corresponding LexicalNode classes registered on the editor.
+ * Normally, you'd get an Array of BaseSerialized nodes from {@link $generateJSONFromSelectedNodes}
+ *
+ * @param serializedNodes an Array of objects conforming to the BaseSerializedNode interface.
+ * @returns an Array of Lexical Node objects.
+ */
+export function $generateNodesFromSerializedNodes(serializedNodes) {
+  var nodes = [];
+  var _iterator4 = _createForOfIteratorHelper(serializedNodes),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var serializedNode = _step4.value;
+      var node = $parseSerializedNode(serializedNode);
+      if ($isTextNode(node)) {
+        $addNodeStyle(node);
+      }
+      nodes.push(node);
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  return nodes;
 }

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

@@ -0,0 +1,7 @@
+export declare const logger: {
+    debug: import("debug").Debugger;
+    error: (...args: any[]) => void;
+    info: import("debug").Debugger;
+    log: import("debug").Debugger;
+    warn: (...args: any[]) => void;
+};

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

@@ -0,0 +1,2 @@
+import { createDebugLogger } from "../../../utils/debug";
+export var logger = createDebugLogger('plugin', 'markdown');

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

@@ -20,6 +20,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 { $createNodeSelection, $setSelection } from 'lexical';
+import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
 import { IMarkdownShortCutService } from "../../markdown";
 import { createDebugLogger } from "../../../utils/debug";
@@ -32,7 +33,6 @@ export var MathPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(MathPlugin, _KernelPlugin);
   var _super = _createSuper(MathPlugin);
   function MathPlugin(kernel, config) {
-    var _kernel$requireServic, _kernel$requireServic2, _kernel$requireServic3, _kernel$requireServic4;
     var _this;
     _classCallCheck(this, MathPlugin);
     _this = _super.call(this);
@@ -49,56 +49,75 @@ export var MathPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     _this.registerDecorator(kernel, MathBlockNode.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.registerMarkdownShortCut({
-      regExp: /\$([^$]+)\$\s?$/,
-      replace: function replace(textNode, match) {
-        var _match = _slicedToArray(match, 2),
-          code = _match[1];
-        var mathNode = $createMathInlineNode(code);
-        _this.logger.debug('Math node inserted:', mathNode);
-        // textNode.replace(mathNode);
-        textNode.insertBefore(mathNode);
-        textNode.setTextContent('');
-        textNode.select();
-        // mathNode.selectEnd();
-
-        return;
-      },
-      trigger: '$',
-      type: 'text-match'
-    });
-    (_kernel$requireServic2 = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic2 === void 0 || _kernel$requireServic2.registerMarkdownShortCut({
-      regExp: /^(\$\$)$/,
-      replace: function replace(parentNode, _1, _2, isImport) {
-        var node = $createMathBlockNode();
-
-        // TODO: Get rid of isImport flag
-        if (isImport || parentNode.getNextSibling()) {
-          parentNode.replace(node);
-        } else {
-          parentNode.insertBefore(node);
-        }
-        var sel = $createNodeSelection();
-        sel.add(node.getKey());
-        $setSelection(sel);
-      },
-      trigger: 'enter',
-      type: 'element'
-    });
-    (_kernel$requireServic3 = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic3 === void 0 || _kernel$requireServic3.registerMarkdownWriter(MathInlineNode.getType(), function (ctx, node) {
-      ctx.appendLine(node.getTextContent());
-      return true;
-    });
-    (_kernel$requireServic4 = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic4 === void 0 || _kernel$requireServic4.registerMarkdownWriter(MathBlockNode.getType(), function (ctx, node) {
-      ctx.appendLine(node.getTextContent());
-      return true;
-    });
     return _this;
   }
   _createClass(MathPlugin, [{
     key: "onInit",
     value: function onInit(editor) {
       this.register(registerMathCommand(editor));
+      this.registerMarkdown();
+    }
+  }, {
+    key: "registerMarkdown",
+    value: function registerMarkdown() {
+      var _this2 = this;
+      var markdownService = this.kernel.requireService(IMarkdownShortCutService);
+      markdownService === null || markdownService === void 0 || markdownService.registerMarkdownShortCut({
+        regExp: /\$([^$]+)\$\s?$/,
+        replace: function replace(textNode, match) {
+          var _match = _slicedToArray(match, 2),
+            code = _match[1];
+          var mathNode = $createMathInlineNode(code);
+          _this2.logger.debug('Math node inserted:', mathNode);
+          // textNode.replace(mathNode);
+          textNode.insertBefore(mathNode);
+          textNode.setTextContent('');
+          textNode.select();
+          // mathNode.selectEnd();
+
+          return;
+        },
+        trigger: '$',
+        type: 'text-match'
+      });
+      markdownService === null || markdownService === void 0 || markdownService.registerMarkdownShortCut({
+        regExp: /^(\$\$)$/,
+        replace: function replace(parentNode, _1, _2, isImport) {
+          var node = $createMathBlockNode();
+
+          // TODO: Get rid of isImport flag
+          if (isImport || parentNode.getNextSibling()) {
+            parentNode.replace(node);
+          } else {
+            parentNode.insertBefore(node);
+          }
+          var sel = $createNodeSelection();
+          sel.add(node.getKey());
+          $setSelection(sel);
+        },
+        trigger: 'enter',
+        type: 'element'
+      });
+      markdownService === null || markdownService === void 0 || markdownService.registerMarkdownWriter(MathInlineNode.getType(), function (ctx, node) {
+        ctx.appendLine(node.getTextContent());
+        return true;
+      });
+      markdownService === null || markdownService === void 0 || markdownService.registerMarkdownWriter(MathBlockNode.getType(), function (ctx, node) {
+        ctx.appendLine(node.getTextContent());
+        return true;
+      });
+      markdownService === null || markdownService === void 0 || markdownService.registerMarkdownReader('inlineMath', function (node) {
+        return INodeHelper.createElementNode('math', {
+          code: node.value,
+          version: 1
+        });
+      });
+      markdownService === null || markdownService === void 0 || markdownService.registerMarkdownReader('math', function (node) {
+        return INodeHelper.createElementNode('mathBlock', {
+          code: node.value,
+          version: 1
+        });
+      });
     }
   }]);
   return MathPlugin;