@lexical/markdown 0.2.4 → 0.2.7

package/LexicalMarkdown.dev.js

@@ -6,12 +6,11 @@
  */
 'use strict';
 
-var code = require('@lexical/code');
-var list = require('@lexical/list');
 var lexical = require('lexical');
+var code = require('@lexical/code');
 var link = require('@lexical/link');
+var list = require('@lexical/list');
 var richText = require('@lexical/rich-text');
-var text = require('@lexical/text');
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -21,834 +20,390 @@ var text = require('@lexical/text');
  *
  * 
  */
-/*
-   How to add a new syntax to capture and transform.
-   1. Create a new enumeration by adding to MarkdownFormatKind.
-   2. Add a new criteria with a regEx pattern. See markdownStrikethrough as an example.
-   3. Add your block criteria (e.g. '# ') to allMarkdownCriteria or 
-      your text criteria (e.g. *MyItalic*) to allMarkdownCriteriaForTextNodes.
-   4. Add your Lexical block specific transforming code here: transformTextNodeForText.   
-      Add your Lexical text specific transforming code here: transformTextNodeForText.   
-   */
-// The trigger state helps to capture EditorState information
-// from the prior and current EditorState.
-// This is then used to determined if an auto format has been triggered.
-
-// Eventually we need to support multiple trigger string's including newlines.
-const SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES = '\u0004'; // Select an unused unicode character to separate text and non-text nodes.
-
-const SEPARATOR_LENGTH = SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES.length;
-const spaceTrigger = {
-  triggerKind: 'space_trigger',
-  triggerString: '\u0020'
-}; // Future todo: add support for ``` + carriage return either inside or not inside code block. Should toggle between.
-// const codeBlockTrigger : AutoFormatTrigger = {
-//     triggerKind: 'codeBlock_trigger',
-//     triggerString: '```', // + new paragraph element or new code block element.
-// };
-
-const triggers = [spaceTrigger
-/*, codeBlockTrigger*/
-]; // Future Todo: speed up performance by having non-capture group variations of the regex.
-
-const autoFormatBase = {
-  markdownFormatKind: null,
-  regEx: /(?:)/,
-  regExForAutoFormatting: /(?:)/,
-  requiresParagraphStart: false
-};
-const paragraphStartBase = { ...autoFormatBase,
-  requiresParagraphStart: true
-};
-const markdownHeader1 = { ...paragraphStartBase,
-  markdownFormatKind: 'paragraphH1',
-  regEx: /^(?:# )/,
-  regExForAutoFormatting: /^(?:# )/
-};
-const markdownHeader2 = { ...paragraphStartBase,
-  markdownFormatKind: 'paragraphH2',
-  regEx: /^(?:## )/,
-  regExForAutoFormatting: /^(?:## )/
-};
-const markdownHeader3 = { ...paragraphStartBase,
-  markdownFormatKind: 'paragraphH3',
-  regEx: /^(?:### )/,
-  regExForAutoFormatting: /^(?:### )/
-};
-const markdownHeader4 = { ...paragraphStartBase,
-  markdownFormatKind: 'paragraphH4',
-  regEx: /^(?:#### )/,
-  regExForAutoFormatting: /^(?:#### )/
-};
-const markdownHeader5 = { ...paragraphStartBase,
-  markdownFormatKind: 'paragraphH5',
-  regEx: /^(?:##### )/,
-  regExForAutoFormatting: /^(?:##### )/
-};
-const markdownBlockQuote = { ...paragraphStartBase,
-  markdownFormatKind: 'paragraphBlockQuote',
-  regEx: /^(?:> )/,
-  regExForAutoFormatting: /^(?:> )/
-};
-const markdownUnorderedListDash = { ...paragraphStartBase,
-  markdownFormatKind: 'paragraphUnorderedList',
-  regEx: /^(\s{0,10})(?:- )/,
-  regExForAutoFormatting: /^(\s{0,10})(?:- )/
-};
-const markdownUnorderedListAsterisk = { ...paragraphStartBase,
-  markdownFormatKind: 'paragraphUnorderedList',
-  regEx: /^(\s{0,10})(?:\* )/,
-  regExForAutoFormatting: /^(\s{0,10})(?:\* )/
-};
-const markdownCodeBlock = { ...paragraphStartBase,
-  markdownFormatKind: 'paragraphCodeBlock',
-  regEx: /^(```)$/,
-  regExForAutoFormatting: /^(```)([a-z]*)( )/
-};
-const markdownOrderedList = { ...paragraphStartBase,
-  markdownFormatKind: 'paragraphOrderedList',
-  regEx: /^(\s{0,10})(\d+)\.\s/,
-  regExForAutoFormatting: /^(\s{0,10})(\d+)\.\s/
-};
-const markdownHorizontalRule = { ...paragraphStartBase,
-  markdownFormatKind: 'horizontalRule',
-  regEx: /^(?:\*\*\*)$/,
-  regExForAutoFormatting: /^(?:\*\*\* )/
-};
-const markdownHorizontalRuleUsingDashes = { ...paragraphStartBase,
-  markdownFormatKind: 'horizontalRule',
-  regEx: /^(?:---)$/,
-  regExForAutoFormatting: /^(?:--- )/
-};
-const markdownInlineCode = { ...autoFormatBase,
-  markdownFormatKind: 'code',
-  regEx: /(`)([^`]*)(`)/,
-  regExForAutoFormatting: /(`)(\s*\b)([^`]*)(\b\s*)(`)(\s)$/
-};
-const markdownBold = { ...autoFormatBase,
-  markdownFormatKind: 'bold',
-  regEx: /(\*\*)(\s*)([^\*\*]*)(\s*)(\*\*)()/,
-  regExForAutoFormatting: /(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)(\s)$/
-};
-const markdownItalic = { ...autoFormatBase,
-  markdownFormatKind: 'italic',
-  regEx: /(\*)(\s*)([^\*]*)(\s*)(\*)()/,
-  regExForAutoFormatting: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*)(\s)$/
-};
-const markdownBold2 = { ...autoFormatBase,
-  markdownFormatKind: 'bold',
-  regEx: /(__)(\s*)([^__]*)(\s*)(__)()/,
-  regExForAutoFormatting: /(__)(\s*)([^__]*)(\s*)(__)(\s)$/
-};
-const markdownItalic2 = { ...autoFormatBase,
-  markdownFormatKind: 'italic',
-  regEx: /(_)()([^_]*)()(_)()/,
-  regExForAutoFormatting: /(_)()([^_]*)()(_)(\s)$/ // Maintain 7 groups.
-
-}; // Markdown does not support underline, but we can allow folks to use
-// the HTML tags for underline.
-
-const fakeMarkdownUnderline = { ...autoFormatBase,
-  markdownFormatKind: 'underline',
-  regEx: /(\<u\>)(\s*)([^\<]*)(\s*)(\<\/u\>)()/,
-  regExForAutoFormatting: /(\<u\>)(\s*\b)([^\<]*)(\b\s*)(\<\/u\>)(\s)$/
-};
-const markdownStrikethrough = { ...autoFormatBase,
-  markdownFormatKind: 'strikethrough',
-  regEx: /(~~)(\s*)([^~~]*)(\s*)(~~)()/,
-  regExForAutoFormatting: /(~~)(\s*\b)([^~~]*)(\b\s*)(~~)(\s)$/
-};
-const markdownStrikethroughItalicBold = { ...autoFormatBase,
-  markdownFormatKind: 'strikethrough_italic_bold',
-  regEx: /(~~_\*\*)(\s*\b)([^~~_\*\*][^\*\*_~~]*)(\b\s*)(\*\*_~~)()/,
-  regExForAutoFormatting: /(~~_\*\*)(\s*\b)([^~~_\*\*][^\*\*_~~]*)(\b\s*)(\*\*_~~)(\s)$/
-};
-const markdownItalicbold = { ...autoFormatBase,
-  markdownFormatKind: 'italic_bold',
-  regEx: /(_\*\*)(\s*\b)([^_\*\*][^\*\*_]*)(\b\s*)(\*\*_)/,
-  regExForAutoFormatting: /(_\*\*)(\s*\b)([^_\*\*][^\*\*_]*)(\b\s*)(\*\*_)(\s)$/
-};
-const markdownStrikethroughItalic = { ...autoFormatBase,
-  markdownFormatKind: 'strikethrough_italic',
-  regEx: /(~~_)(\s*)([^~~_][^_~~]*)(\s*)(_~~)/,
-  regExForAutoFormatting: /(~~_)(\s*)([^~~_][^_~~]*)(\s*)(_~~)(\s)$/
-};
-const markdownStrikethroughBold = { ...autoFormatBase,
-  markdownFormatKind: 'strikethrough_bold',
-  regEx: /(~~\*\*)(\s*\b)([^~~\*\*][^\*\*~~]*)(\b\s*)(\*\*~~)/,
-  regExForAutoFormatting: /(~~\*\*)(\s*\b)([^~~\*\*][^\*\*~~]*)(\b\s*)(\*\*~~)(\s)$/
-};
-const markdownLink = { ...autoFormatBase,
-  markdownFormatKind: 'link',
-  regEx: /(\[)([^\]]*)(\]\()([^)]*)(\)*)()/,
-  regExForAutoFormatting: /(\[)([^\]]*)(\]\()([^)]*)(\)*)(\s)$/
-};
-const allMarkdownCriteriaForTextNodes = [// Place the combination formats ahead of the individual formats.
-// Combos
-markdownStrikethroughItalicBold, markdownItalicbold, markdownStrikethroughItalic, markdownStrikethroughBold, // Individuals
-markdownInlineCode, markdownBold, markdownItalic, // Must appear after markdownBold
-markdownBold2, markdownItalic2, // Must appear after markdownBold2.
-fakeMarkdownUnderline, markdownStrikethrough, markdownLink];
-const allMarkdownCriteriaForParagraphs = [markdownHeader1, markdownHeader2, markdownHeader3, markdownHeader4, markdownHeader5, markdownBlockQuote, markdownUnorderedListDash, markdownUnorderedListAsterisk, markdownOrderedList, markdownCodeBlock, markdownHorizontalRule, markdownHorizontalRuleUsingDashes];
-const allMarkdownCriteria = [...allMarkdownCriteriaForParagraphs, ...allMarkdownCriteriaForTextNodes];
-function getAllTriggers() {
-  return triggers;
-}
-function getAllMarkdownCriteriaForParagraphs() {
-  return allMarkdownCriteriaForParagraphs;
-}
-function getAllMarkdownCriteriaForTextNodes() {
-  return allMarkdownCriteriaForTextNodes;
-}
-function getAllMarkdownCriteria() {
-  return allMarkdownCriteria;
+function indexBy(list, callback) {
+  const index = {};
+
+  for (const item of list) {
+    const key = callback(item);
+
+    if (index[key]) {
+      index[key].push(item);
+    } else {
+      index[key] = [item];
+    }
+  }
+
+  return index;
 }
-function getInitialScanningContext(editor, isAutoFormatting, textNodeWithOffset, triggerState) {
+function transformersByType(transformers) {
+  const byType = indexBy(transformers, t => t.type);
   return {
-    currentElementNode: null,
-    editor,
-    isAutoFormatting,
-    isWithinCodeBlock: false,
-    joinedText: null,
-    markdownCriteria: {
-      markdownFormatKind: 'noTransformation',
-      regEx: /(?:)/,
-      // Empty reg ex.
-      regExForAutoFormatting: /(?:)/,
-      // Empty reg ex.
-      requiresParagraphStart: null
-    },
-    patternMatchResults: {
-      regExCaptureGroups: []
-    },
-    textNodeWithOffset,
-    triggerState
-  };
-}
-function resetScanningContext(scanningContext) {
-  scanningContext.joinedText = null;
-  scanningContext.markdownCriteria = {
-    markdownFormatKind: 'noTransformation',
-    regEx: /(?:)/,
-    // Empty reg ex.
-    regExForAutoFormatting: /(?:)/,
-    // Empty reg ex.
-    requiresParagraphStart: null
+    // $FlowFixMe
+    element: byType.element,
+    // $FlowFixMe
+    textFormat: byType['text-format'],
+    // $FlowFixMe
+    textMatch: byType['text-match']
   };
-  scanningContext.patternMatchResults = {
-    regExCaptureGroups: []
-  };
-  scanningContext.triggerState = null;
-  scanningContext.textNodeWithOffset = null;
-  return scanningContext;
-}
-function getCodeBlockCriteria() {
-  return markdownCodeBlock;
 }
-function getPatternMatchResultsForCriteria(markdownCriteria, scanningContext, parentElementNode) {
-  if (markdownCriteria.requiresParagraphStart === true) {
-    return getPatternMatchResultsForParagraphs(markdownCriteria, scanningContext);
-  }
 
-  return getPatternMatchResultsForText(markdownCriteria, scanningContext, parentElementNode);
-}
-function getPatternMatchResultsForCodeBlock(scanningContext, text) {
-  const markdownCriteria = getCodeBlockCriteria();
-  return getPatternMatchResultsWithRegEx(text, true, false, scanningContext.isAutoFormatting ? markdownCriteria.regExForAutoFormatting : markdownCriteria.regEx);
-}
+/**
+ * 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.
+ *
+ * 
+ */
+function createMarkdownExport(transformers) {
+  const byType = transformersByType(transformers); // Export only uses text formats that are responsible for single format
+  // e.g. it will filter out *** (bold, italic) and instead use separate ** and *
 
-function getPatternMatchResultsWithRegEx(textToSearch, matchMustAppearAtStartOfString, matchMustAppearAtEndOfString, regEx) {
-  const patternMatchResults = {
-    regExCaptureGroups: []
-  };
-  const regExMatches = textToSearch.match(regEx);
-
-  if (regExMatches !== null && regExMatches.length > 0 && (matchMustAppearAtStartOfString === false || regExMatches.index === 0) && (matchMustAppearAtEndOfString === false || regExMatches.index + regExMatches[0].length === textToSearch.length)) {
-    const captureGroupsCount = regExMatches.length;
-    let runningLength = regExMatches.index;
-
-    for (let captureGroupIndex = 0; captureGroupIndex < captureGroupsCount; captureGroupIndex++) {
-      const textContent = regExMatches[captureGroupIndex];
-      patternMatchResults.regExCaptureGroups.push({
-        offsetInParent: runningLength,
-        text: textContent
-      }); // The 0th capture group is special in that it's text contents is
-      // a join of all subsequent capture groups. So, skip this group
-      // when calculating the runningLength.
-
-      if (captureGroupIndex > 0) {
-        runningLength += textContent.length;
+  const textFormatTransformers = byType.textFormat.filter(transformer => transformer.format.length === 1);
+  return () => {
+    const output = [];
+    const children = lexical.$getRoot().getChildren();
+
+    for (const child of children) {
+      const result = exportTopLevelElements(child, byType.element, textFormatTransformers, byType.textMatch);
+
+      if (result != null) {
+        output.push(result);
       }
     }
 
-    return patternMatchResults;
-  }
-
-  return null;
+    return output.join('\n');
+  };
 }
 
-function hasPatternMatchResults(scanningContext) {
-  return scanningContext.patternMatchResults.regExCaptureGroups.length > 0;
-}
-function getTextNodeWithOffsetOrThrow(scanningContext) {
-  const textNodeWithOffset = scanningContext.textNodeWithOffset;
+function exportTopLevelElements(node, elementTransformers, textTransformersIndex, textMatchTransformers) {
+  for (const transformer of elementTransformers) {
+    const result = transformer.export(node, _node => exportChildren(_node, textTransformersIndex, textMatchTransformers));
 
-  if (textNodeWithOffset == null) {
-    {
-      throw Error(`Expect to have a text node with offset.`);
+    if (result != null) {
+      return result;
     }
   }
 
-  return textNodeWithOffset;
+  return lexical.$isElementNode(node) ? exportChildren(node, textTransformersIndex, textMatchTransformers) : null;
 }
 
-function getPatternMatchResultsForParagraphs(markdownCriteria, scanningContext) {
-  const textNodeWithOffset = getTextNodeWithOffsetOrThrow(scanningContext); // At start of paragraph.
-
-  if (textNodeWithOffset.node.getPreviousSibling() === null) {
-    const textToSearch = textNodeWithOffset.node.getTextContent();
-    return getPatternMatchResultsWithRegEx(textToSearch, true, false, scanningContext.isAutoFormatting ? markdownCriteria.regExForAutoFormatting : markdownCriteria.regEx);
-  }
+function exportChildren(node, textTransformersIndex, textMatchTransformers) {
+  const output = [];
+  const children = node.getChildren();
 
-  return null;
-}
+  mainLoop: for (const child of children) {
+    if (lexical.$isLineBreakNode(child)) {
+      output.push('\n');
+    } else if (lexical.$isTextNode(child)) {
+      output.push(exportTextFormat(child, child.getTextContent(), textTransformersIndex));
+    } else {
+      for (const transformer of textMatchTransformers) {
+        const result = transformer.export(child, parentNode => exportChildren(parentNode, textTransformersIndex, textMatchTransformers), (textNode, textContent) => exportTextFormat(textNode, textContent, textTransformersIndex));
 
-function getPatternMatchResultsForText(markdownCriteria, scanningContext, parentElementNode) {
-  if (scanningContext.joinedText == null) {
-    if (lexical.$isElementNode(parentElementNode)) {
-      if (scanningContext.joinedText == null) {
-        // Lazy calculate the text to search.
-        scanningContext.joinedText = text.$joinTextNodesInElementNode(parentElementNode, SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES, getTextNodeWithOffsetOrThrow(scanningContext));
+        if (result != null) {
+          output.push(result);
+          continue mainLoop;
+        }
       }
-    } else {
-      {
-        throw Error(`Expected node ${parentElementNode.__key} to to be a ElementNode.`);
+
+      if (lexical.$isElementNode(child)) {
+        output.push(exportChildren(child, textTransformersIndex, textMatchTransformers));
       }
     }
   }
 
-  const matchMustAppearAtEndOfString = markdownCriteria.regExForAutoFormatting === true;
-  return getPatternMatchResultsWithRegEx(scanningContext.joinedText, false, matchMustAppearAtEndOfString, scanningContext.isAutoFormatting ? markdownCriteria.regExForAutoFormatting : markdownCriteria.regEx);
+  return output.join('');
 }
 
-function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNode) {
-  let newNode = null;
-  const shouldDelete = false;
-  const children = element.getChildren();
-  const markdownCriteria = scanningContext.markdownCriteria;
-  const patternMatchResults = scanningContext.patternMatchResults;
-
-  if (markdownCriteria.markdownFormatKind != null) {
-    switch (markdownCriteria.markdownFormatKind) {
-      case 'paragraphH1':
-        {
-          newNode = richText.$createHeadingNode('h1');
-          newNode.append(...children);
-          return {
-            newNode,
-            shouldDelete
-          };
-        }
+function exportTextFormat(node, textContent, textTransformers) {
+  let output = textContent;
+  const applied = new Set();
 
-      case 'paragraphH2':
-        {
-          newNode = richText.$createHeadingNode('h2');
-          newNode.append(...children);
-          return {
-            newNode,
-            shouldDelete
-          };
-        }
+  for (const transformer of textTransformers) {
+    const format = transformer.format[0];
+    const tag = transformer.tag;
 
-      case 'paragraphH3':
-        {
-          newNode = richText.$createHeadingNode('h3');
-          newNode.append(...children);
-          return {
-            newNode,
-            shouldDelete
-          };
-        }
+    if (hasFormat(node, format) && !applied.has(format)) {
+      // Multiple tags might be used for the same format (*, _)
+      applied.add(format); // Prevent adding opening tag is already opened by the previous sibling
 
-      case 'paragraphH4':
-        {
-          newNode = richText.$createHeadingNode('h4');
-          newNode.append(...children);
-          return {
-            newNode,
-            shouldDelete
-          };
-        }
+      const previousNode = getTextSibling(node, true);
 
-      case 'paragraphH5':
-        {
-          newNode = richText.$createHeadingNode('h5');
-          newNode.append(...children);
-          return {
-            newNode,
-            shouldDelete
-          };
-        }
+      if (!hasFormat(previousNode, format)) {
+        output = tag + output;
+      } // Prevent adding closing tag if next sibling will do it
 
-      case 'paragraphBlockQuote':
-        {
-          newNode = richText.$createQuoteNode();
-          newNode.append(...children);
-          return {
-            newNode,
-            shouldDelete
-          };
-        }
 
-      case 'paragraphUnorderedList':
-        {
-          createListOrMergeWithPrevious(element, children, patternMatchResults, 'ul');
-          return {
-            newNode: null,
-            shouldDelete: false
-          };
-        }
+      const nextNode = getTextSibling(node, false);
 
-      case 'paragraphOrderedList':
-        {
-          const startAsString = patternMatchResults.regExCaptureGroups.length > 1 ? patternMatchResults.regExCaptureGroups[patternMatchResults.regExCaptureGroups.length - 1].text : '1'; // For conversion, don't use start number.
-          // For short-cuts aka autoFormatting, use start number.
-          // Later, this should be surface dependent and externalized.
-
-          const start = scanningContext.isAutoFormatting ? parseInt(startAsString, 10) : undefined;
-          createListOrMergeWithPrevious(element, children, patternMatchResults, 'ol', start);
-          return {
-            newNode: null,
-            shouldDelete: false
-          };
-        }
+      if (!hasFormat(nextNode, format)) {
+        output += tag;
+      }
+    }
+  }
 
-      case 'paragraphCodeBlock':
-        {
-          // Toggle code and paragraph nodes.
-          if (scanningContext.isAutoFormatting === false) {
-            const shouldToggle = hasPatternMatchResults(scanningContext);
-
-            if (shouldToggle) {
-              scanningContext.isWithinCodeBlock = scanningContext.isWithinCodeBlock !== true; // When toggling, always clear the code block element node.
-
-              scanningContext.currentElementNode = null;
-              return {
-                newNode: null,
-                shouldDelete: true
-              };
-            }
-
-            if (scanningContext.isWithinCodeBlock) {
-              // Create the code block and return it to the caller.
-              if (scanningContext.currentElementNode == null) {
-                const newCodeBlockNode = code.$createCodeNode();
-                newCodeBlockNode.append(...children);
-                scanningContext.currentElementNode = newCodeBlockNode;
-                return {
-                  newNode: newCodeBlockNode,
-                  shouldDelete: false
-                };
-              } // Build up the code block with a line break and the children.
-
-
-              if (scanningContext.currentElementNode != null) {
-                const codeBlockNode = scanningContext.currentElementNode;
-                const lineBreakNode = lexical.$createLineBreakNode();
-                codeBlockNode.append(lineBreakNode);
-
-                if (children.length) {
-                  codeBlockNode.append(lineBreakNode);
-                }
-
-                codeBlockNode.append(...children);
-              }
-            }
-
-            return {
-              newNode: null,
-              shouldDelete: true
-            };
-          }
-
-          if (scanningContext.triggerState != null && scanningContext.triggerState.isCodeBlock) {
-            newNode = lexical.$createParagraphNode();
-          } else {
-            newNode = code.$createCodeNode();
-            const codingLanguage = patternMatchResults.regExCaptureGroups.length >= 3 ? patternMatchResults.regExCaptureGroups[2].text : null;
-
-            if (codingLanguage != null && codingLanguage.length > 0) {
-              newNode.setLanguage(codingLanguage);
-            }
-          }
-
-          newNode.append(...children);
-          return {
-            newNode,
-            shouldDelete
-          };
-        }
+  return output;
+} // Get next or previous text sibling a text node, including cases
+// when it's a child of inline element (e.g. link)
 
-      case 'horizontalRule':
-        {
-          if (createHorizontalRuleNode != null) {
-            // return null for newNode. Insert the HR here.
-            const horizontalRuleNode = createHorizontalRuleNode();
-            element.insertBefore(horizontalRuleNode);
-          }
 
-          break;
-        }
+function getTextSibling(node, backward) {
+  let sibling = backward ? node.getPreviousSibling() : node.getNextSibling();
+
+  if (!sibling) {
+    const parent = node.getParentOrThrow();
+
+    if (parent.isInline()) {
+      sibling = backward ? parent.getPreviousSibling() : parent.getNextSibling();
     }
   }
 
-  return {
-    newNode,
-    shouldDelete
-  };
-}
+  while (sibling) {
+    if (lexical.$isElementNode(sibling)) {
+      if (!sibling.isInline()) {
+        break;
+      }
 
-function createListOrMergeWithPrevious(element, children, patternMatchResults, tag, start) {
-  const listItem = list.$createListItemNode();
-  const indentMatch = patternMatchResults.regExCaptureGroups[0].text.match(/^\s*/);
-  const indent = indentMatch ? Math.floor(indentMatch[0].length / 4) : 0;
-  listItem.append(...children); // Checking if previous element is a list, and if so append
-  // new list item inside instead of creating new list
+      const descendant = backward ? sibling.getLastDescendant() : sibling.getFirstDescendant();
 
-  const prevElement = element.getPreviousSibling();
+      if (lexical.$isTextNode(descendant)) {
+        return descendant;
+      } else {
+        sibling = backward ? sibling.getPreviousSibling() : sibling.getNextSibling();
+      }
+    }
 
-  if (list.$isListNode(prevElement) && prevElement.getTag() === tag) {
-    prevElement.append(listItem);
-    element.remove();
-  } else {
-    const list$1 = list.$createListNode(tag, start);
-    list$1.append(listItem);
-    element.replace(list$1);
+    if (lexical.$isTextNode(sibling)) {
+      return sibling;
+    }
   }
 
-  if (indent) {
-    listItem.setIndent(indent);
-  }
+  return null;
 }
 
-function transformTextNodeForMarkdownCriteria(scanningContext, elementNode, createHorizontalRuleNode) {
-  if (scanningContext.markdownCriteria.requiresParagraphStart === true) {
-    transformTextNodeForElementNode(elementNode, scanningContext, createHorizontalRuleNode);
-  } else {
-    transformTextNodeForText(scanningContext, elementNode);
-  }
+function hasFormat(node, format) {
+  return lexical.$isTextNode(node) && node.hasFormat(format);
 }
 
-function transformTextNodeForElementNode(elementNode, scanningContext, createHorizontalRuleNode) {
-  if (scanningContext.textNodeWithOffset != null) {
-    const textNodeWithOffset = getTextNodeWithOffsetOrThrow(scanningContext);
+/**
+ * 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.
+ *
+ * 
+ */
+const CODE_BLOCK_REG_EXP = /^```(\w{1,10})?\s?$/;
+function createMarkdownImport(transformers) {
+  const byType = transformersByType(transformers);
+  const textFormatTransformersIndex = createTextFormatTransformersIndex(byType.textFormat);
+  return markdownString => {
+    const lines = markdownString.split('\n');
+    const linesLength = lines.length;
+    const root = lexical.$getRoot();
+    root.clear();
 
-    if (hasPatternMatchResults(scanningContext)) {
-      const text = scanningContext.patternMatchResults.regExCaptureGroups[0].text; // Remove the text which we matched.
+    for (let i = 0; i < linesLength; i++) {
+      const lineText = lines[i]; // Codeblocks are processed first as anything inside such block
+      // is ignored for further processing
+      // TODO:
+      // Abstract it to be dynamic as other transformers (add multiline match option)
 
-      const textNode = textNodeWithOffset.node.spliceText(0, text.length, '', true);
+      const [codeBlockNode, shiftedIndex] = importCodeBlock(lines, i, root);
 
-      if (textNode.getTextContent() === '') {
-        textNode.selectPrevious();
-        textNode.remove();
+      if (codeBlockNode != null) {
+        i = shiftedIndex;
+        continue;
       }
-    }
-  } // Transform the current element kind to the new element kind.
 
+      importBlocks(lineText, root, byType.element, textFormatTransformersIndex, byType.textMatch);
+    }
 
-  const {
-    newNode,
-    shouldDelete
-  } = getNewNodeForCriteria(scanningContext, elementNode, createHorizontalRuleNode);
-
-  if (shouldDelete) {
-    elementNode.remove();
-  } else if (newNode !== null) {
-    elementNode.replace(newNode);
-  }
+    root.selectEnd();
+  };
 }
 
-function transformTextNodeForText(scanningContext, parentElementNode) {
-  const markdownCriteria = scanningContext.markdownCriteria;
+function importBlocks(lineText, rootNode, elementTransformers, textFormatTransformersIndex, textMatchTransformers) {
+  const textNode = lexical.$createTextNode(lineText);
+  const elementNode = lexical.$createParagraphNode();
+  elementNode.append(textNode);
+  rootNode.append(elementNode);
 
-  if (markdownCriteria.markdownFormatKind != null) {
-    const formatting = getTextFormatType(markdownCriteria.markdownFormatKind);
+  for (const {
+    regExp,
+    replace
+  } of elementTransformers) {
+    const match = lineText.match(regExp);
 
-    if (formatting != null) {
-      transformTextNodeWithFormatting(formatting, scanningContext, parentElementNode);
-      return;
-    }
-
-    if (markdownCriteria.markdownFormatKind === 'link') {
-      transformTextNodeWithLink(scanningContext, parentElementNode);
+    if (match) {
+      textNode.setTextContent(lineText.slice(match[0].length));
+      replace(elementNode, [textNode], match, true);
+      break;
     }
   }
-}
 
-function transformTextNodeWithFormatting(formatting, scanningContext, parentElementNode) {
-  const patternMatchResults = scanningContext.patternMatchResults;
-  const groupCount = patternMatchResults.regExCaptureGroups.length;
-
-  if (groupCount !== 7) {
-    // For BIUS and similar formats which have a pattern + text + pattern:
-    // given '*italic* ' below are the capture groups by index:
-    // 0. '*italic* '
-    // 1. '*'
-    // 2. whitespace  // typically this is "".
-    // 3. 'italic'
-    // 4. whitespace  // typicallly this is "".
-    // 5. '*'
-    // 6. ' '
-    return;
-  } // Remove unwanted text in reg ex pattern.
-  // Remove group 5.
-
-
-  removeTextByCaptureGroups(5, 5, scanningContext, parentElementNode); // Remove group 1.
+  importTextFormatTransformers(textNode, textFormatTransformersIndex, textMatchTransformers);
+}
 
-  removeTextByCaptureGroups(1, 1, scanningContext, parentElementNode); // Apply the formatting.
+function importCodeBlock(lines, startLineIndex, rootNode) {
+  const openMatch = lines[startLineIndex].match(CODE_BLOCK_REG_EXP);
 
-  formatTextInCaptureGroupIndex(formatting, 3, scanningContext, parentElementNode); // Place caret at end of final capture group.
+  if (openMatch) {
+    let endLineIndex = startLineIndex;
+    const linesLength = lines.length;
 
-  selectAfterFinalCaptureGroup(scanningContext, parentElementNode);
-}
+    while (++endLineIndex < linesLength) {
+      const closeMatch = lines[endLineIndex].match(CODE_BLOCK_REG_EXP);
 
-function transformTextNodeWithLink(scanningContext, parentElementNode) {
-  const patternMatchResults = scanningContext.patternMatchResults;
-  const regExCaptureGroups = patternMatchResults.regExCaptureGroups;
-  const groupCount = regExCaptureGroups.length;
-
-  if (groupCount !== 7) {
-    // For links and similar formats which have: pattern + text + pattern + pattern2 text2 + pattern2:
-    // Given '[title](url) ', below are the capture groups by index:
-    // 0. '[title](url) '
-    // 1. '['
-    // 2. 'title'
-    // 3. ']('
-    // 4. 'url'
-    // 5. ')'
-    // 6. ' '
-    return;
+      if (closeMatch) {
+        const codeBlockNode = code.$createCodeNode(openMatch[1]);
+        const textNode = lexical.$createTextNode(lines.slice(startLineIndex + 1, endLineIndex).join('\n'));
+        codeBlockNode.append(textNode);
+        rootNode.append(codeBlockNode);
+        return [codeBlockNode, endLineIndex];
+      }
+    }
   }
 
-  const title = regExCaptureGroups[2].text;
-  const url = regExCaptureGroups[4].text;
-
-  if (title.length === 0 || url.length === 0) {
-    return;
-  } // Remove the initial pattern through to the final pattern.
+  return [null, startLineIndex];
+} // Processing text content and replaces text format tags.
+// It takes outermost tag match and its content, creates text node with
+// format based on tag and then recursively executed over node's content
+//
+// E.g. for "*Hello **world**!*" string it will create text node with
+// "Hello **world**!" content and italic format and run recursively over
+// its content to transform "**world**" part
 
 
-  removeTextByCaptureGroups(1, 5, scanningContext, parentElementNode);
-  insertTextPriorToCaptureGroup(1, // Insert at the beginning of the meaningful capture groups, namely index 1. Index 0 refers to the whole matched string.
-  title, scanningContext, parentElementNode);
-  const newSelectionForLink = createSelectionWithCaptureGroups(1, 1, false, true, scanningContext, parentElementNode);
+function importTextFormatTransformers(textNode, textFormatTransformersIndex, textMatchTransformers) {
+  const textContent = textNode.getTextContent();
+  const match = findOutermostMatch(textContent, textFormatTransformersIndex);
 
-  if (newSelectionForLink == null) {
+  if (!match) {
+    // Once text format processing is done run text match transformers, as it
+    // only can span within single text node (unline formats that can cover multiple nodes)
+    importTextMatchTransformers(textNode, textMatchTransformers);
     return;
   }
 
-  lexical.$setSelection(newSelectionForLink);
-  scanningContext.editor.dispatchCommand(link.TOGGLE_LINK_COMMAND, url); // Place caret at end of final capture group.
+  let currentNode, remainderNode; // If matching full content there's no need to run splitText and can reuse existing textNode
+  // to update its content and apply format. E.g. for **_Hello_** string after applying bold
+  // format (**) it will reuse the same text node to apply italic (_)
 
-  selectAfterFinalCaptureGroup(scanningContext, parentElementNode);
-} // Below are lower level helper functions.
-
-
-function getParentElementNodeOrThrow(scanningContext) {
-  return getTextNodeWithOffsetOrThrow(scanningContext).node.getParentOrThrow();
-}
-
-function getJoinedTextLength(patternMatchResults) {
-  const groupCount = patternMatchResults.regExCaptureGroups.length;
+  if (match[0] === textContent) {
+    currentNode = textNode;
+  } else {
+    const startIndex = match.index;
+    const endIndex = startIndex + match[0].length;
 
-  if (groupCount < 2) {
-    // Ignore capture group 0, as regEx defaults the 0th one to the entire matched string.
-    return 0;
+    if (startIndex === 0) {
+      [currentNode, remainderNode] = textNode.splitText(endIndex);
+    } else {
+      [, currentNode, remainderNode] = textNode.splitText(startIndex, endIndex);
+    }
   }
 
-  const lastGroupIndex = groupCount - 1;
-  return patternMatchResults.regExCaptureGroups[lastGroupIndex].offsetInParent + patternMatchResults.regExCaptureGroups[lastGroupIndex].text.length;
-}
+  currentNode.setTextContent(match[2]);
+  const transformer = textFormatTransformersIndex.transformersByTag[match[1]];
 
-function getTextFormatType(markdownFormatKind) {
-  switch (markdownFormatKind) {
-    case 'italic':
-    case 'bold':
-    case 'underline':
-    case 'strikethrough':
-    case 'code':
-      return [markdownFormatKind];
-
-    case 'strikethrough_italic_bold':
-      {
-        return ['strikethrough', 'italic', 'bold'];
+  if (transformer) {
+    for (const format of transformer.format) {
+      if (!currentNode.hasFormat(format)) {
+        currentNode.toggleFormat(format);
       }
+    }
+  } // Recursively run over inner text if it's not inline code
 
-    case 'italic_bold':
-      {
-        return ['italic', 'bold'];
-      }
-
-    case 'strikethrough_italic':
-      {
-        return ['strikethrough', 'italic'];
-      }
-
-    case 'strikethrough_bold':
-      {
-        return ['strikethrough', 'bold'];
-      }
-  }
-
-  return null;
-}
 
-function createSelectionWithCaptureGroups(anchorCaptureGroupIndex, focusCaptureGroupIndex, startAtEndOfAnchor, finishAtEndOfFocus, scanningContext, parentElementNode) {
-  const patternMatchResults = scanningContext.patternMatchResults;
-  const regExCaptureGroups = patternMatchResults.regExCaptureGroups;
-  const regExCaptureGroupsCount = regExCaptureGroups.length;
+  if (!currentNode.hasFormat('code')) {
+    importTextFormatTransformers(currentNode, textFormatTransformersIndex, textMatchTransformers);
+  } // Run over remaining text if any
 
-  if (anchorCaptureGroupIndex >= regExCaptureGroupsCount || focusCaptureGroupIndex >= regExCaptureGroupsCount) {
-    return null;
-  }
 
-  const joinedTextLength = getJoinedTextLength(patternMatchResults);
-  const anchorCaptureGroupDetail = regExCaptureGroups[anchorCaptureGroupIndex];
-  const focusCaptureGroupDetail = regExCaptureGroups[focusCaptureGroupIndex];
-  const anchorLocation = startAtEndOfAnchor ? anchorCaptureGroupDetail.offsetInParent + anchorCaptureGroupDetail.text.length : anchorCaptureGroupDetail.offsetInParent;
-  const focusLocation = finishAtEndOfFocus ? focusCaptureGroupDetail.offsetInParent + focusCaptureGroupDetail.text.length : focusCaptureGroupDetail.offsetInParent;
-  const anchorTextNodeWithOffset = text.$findNodeWithOffsetFromJoinedText(anchorLocation, joinedTextLength, SEPARATOR_LENGTH, parentElementNode);
-  const focusTextNodeWithOffset = text.$findNodeWithOffsetFromJoinedText(focusLocation, joinedTextLength, SEPARATOR_LENGTH, parentElementNode);
-
-  if (anchorTextNodeWithOffset == null && focusTextNodeWithOffset == null && parentElementNode.getChildren().length === 0) {
-    const emptyElementSelection = lexical.$createRangeSelection();
-    emptyElementSelection.anchor.set(parentElementNode.getKey(), 0, 'element');
-    emptyElementSelection.focus.set(parentElementNode.getKey(), 0, 'element');
-    return emptyElementSelection;
+  if (remainderNode) {
+    importTextFormatTransformers(remainderNode, textFormatTransformersIndex, textMatchTransformers);
   }
-
-  if (anchorTextNodeWithOffset == null || focusTextNodeWithOffset == null) {
-    return null;
-  }
-
-  const selection = lexical.$createRangeSelection();
-  selection.anchor.set(anchorTextNodeWithOffset.node.getKey(), anchorTextNodeWithOffset.offset, 'text');
-  selection.focus.set(focusTextNodeWithOffset.node.getKey(), focusTextNodeWithOffset.offset, 'text');
-  return selection;
 }
 
-function removeTextByCaptureGroups(anchorCaptureGroupIndex, focusCaptureGroupIndex, scanningContext, parentElementNode) {
-  const patternMatchResults = scanningContext.patternMatchResults;
-  const regExCaptureGroups = patternMatchResults.regExCaptureGroups;
-  const newSelection = createSelectionWithCaptureGroups(anchorCaptureGroupIndex, focusCaptureGroupIndex, false, true, scanningContext, parentElementNode);
-
-  if (newSelection != null) {
-    lexical.$setSelection(newSelection);
-    const currentSelection = lexical.$getSelection();
-
-    if (currentSelection != null && lexical.$isRangeSelection(currentSelection) && currentSelection.isCollapsed() === false) {
-      currentSelection.removeText(); // Shift all group offsets and clear out group text.
+function importTextMatchTransformers(textNode_, textMatchTransformers) {
+  let textNode = textNode_;
 
-      let runningLength = 0;
-      const groupCount = regExCaptureGroups.length;
+  mainLoop: while (textNode) {
+    for (const transformer of textMatchTransformers) {
+      const match = textNode.getTextContent().match(transformer.importRegExp);
 
-      for (let i = anchorCaptureGroupIndex; i < groupCount; i++) {
-        const captureGroupDetail = regExCaptureGroups[i];
+      if (!match) {
+        continue;
+      }
 
-        if (i > anchorCaptureGroupIndex) {
-          captureGroupDetail.offsetInParent -= runningLength;
-        }
+      const startIndex = match.index;
+      const endIndex = startIndex + match[0].length;
+      let replaceNode;
 
-        if (i <= focusCaptureGroupIndex) {
-          runningLength += captureGroupDetail.text.length;
-          captureGroupDetail.text = '';
-        }
+      if (startIndex === 0) {
+        [replaceNode, textNode] = textNode.splitText(endIndex);
+      } else {
+        [, replaceNode, textNode] = textNode.splitText(startIndex, endIndex);
       }
-    }
-  }
-}
 
-function insertTextPriorToCaptureGroup(captureGroupIndex, text, scanningContext, parentElementNode) {
-  const patternMatchResults = scanningContext.patternMatchResults;
-  const regExCaptureGroups = patternMatchResults.regExCaptureGroups;
-  const regExCaptureGroupsCount = regExCaptureGroups.length;
+      transformer.replace(replaceNode, match);
+      continue mainLoop;
+    }
 
-  if (captureGroupIndex >= regExCaptureGroupsCount) {
-    return;
+    break;
   }
+} // Finds first "<tag>content<tag>" match that is not nested into another tag
 
-  const captureGroupDetail = regExCaptureGroups[captureGroupIndex];
-  const newCaptureGroupDetail = {
-    offsetInParent: captureGroupDetail.offsetInParent,
-    text
-  };
-  const newSelection = createSelectionWithCaptureGroups(captureGroupIndex, captureGroupIndex, false, false, scanningContext, parentElementNode);
-
-  if (newSelection != null) {
-    lexical.$setSelection(newSelection);
-    const currentSelection = lexical.$getSelection();
-
-    if (currentSelection != null && lexical.$isRangeSelection(currentSelection) && currentSelection.isCollapsed()) {
-      currentSelection.insertText(newCaptureGroupDetail.text); // Update the capture groups.
-
-      regExCaptureGroups.splice(captureGroupIndex, 0, newCaptureGroupDetail);
-      const textLength = newCaptureGroupDetail.text.length;
-      const newGroupCount = regExCaptureGroups.length;
-
-      for (let i = captureGroupIndex + 1; i < newGroupCount; i++) {
-        const currentCaptureGroupDetail = regExCaptureGroups[i];
-        currentCaptureGroupDetail.offsetInParent += textLength;
-      }
-    }
-  }
-}
 
-function formatTextInCaptureGroupIndex(formatTypes, captureGroupIndex, scanningContext, parentElementNode) {
-  const patternMatchResults = scanningContext.patternMatchResults;
-  const regExCaptureGroups = patternMatchResults.regExCaptureGroups;
-  const regExCaptureGroupsCount = regExCaptureGroups.length;
+function findOutermostMatch(textContent, textTransformersIndex) {
+  const openTagsMatch = textContent.match(textTransformersIndex.openTagsRegExp);
 
-  if (!(captureGroupIndex < regExCaptureGroupsCount)) {
-    throw Error(`The capture group count in the RegEx does match the actual capture group count.`);
+  if (openTagsMatch == null) {
+    return null;
   }
 
-  const captureGroupDetail = regExCaptureGroups[captureGroupIndex];
-
-  if (captureGroupDetail.text.length === 0) {
-    return;
-  }
+  for (const match of openTagsMatch) {
+    // Open tags reg exp might capture leading space so removing it
+    // before using match to find transformer
+    const fullMatchRegExp = textTransformersIndex.fullMatchRegExpByTag[match.replace(/^\s/, '')];
 
-  const newSelection = createSelectionWithCaptureGroups(captureGroupIndex, captureGroupIndex, false, true, scanningContext, parentElementNode);
+    if (fullMatchRegExp == null) {
+      continue;
+    }
 
-  if (newSelection != null) {
-    lexical.$setSelection(newSelection);
-    const currentSelection = lexical.$getSelection();
+    const fullMatch = textContent.match(fullMatchRegExp);
 
-    if (lexical.$isRangeSelection(currentSelection)) {
-      for (let i = 0; i < formatTypes.length; i++) {
-        currentSelection.formatText(formatTypes[i]);
-      }
+    if (fullMatch != null) {
+      return fullMatch;
     }
   }
-} // Place caret at end of final capture group.
 
+  return null;
+}
 
-function selectAfterFinalCaptureGroup(scanningContext, parentElementNode) {
-  const patternMatchResults = scanningContext.patternMatchResults;
-  const groupCount = patternMatchResults.regExCaptureGroups.length;
+function createTextFormatTransformersIndex(textTransformers) {
+  const transformersByTag = {};
+  const fullMatchRegExpByTag = {};
+  const openTagsRegExp = [];
 
-  if (groupCount < 2) {
-    // Ignore capture group 0, as regEx defaults the 0th one to the entire matched string.
-    return;
+  for (const transformer of textTransformers) {
+    const {
+      tag
+    } = transformer;
+    transformersByTag[tag] = transformer;
+    const tagRegExp = tag.replace(/(\*|\^)/g, '\\$1');
+    openTagsRegExp.push(tagRegExp);
+    fullMatchRegExpByTag[tag] = new RegExp(`(${tagRegExp})(?![${tagRegExp}\\s])(.*?[^${tagRegExp}\\s])${tagRegExp}(?!${tagRegExp})`);
   }
 
-  const lastGroupIndex = groupCount - 1;
-  const newSelection = createSelectionWithCaptureGroups(lastGroupIndex, lastGroupIndex, true, true, scanningContext, parentElementNode);
-
-  if (newSelection != null) {
-    lexical.$setSelection(newSelection);
-  }
+  return {
+    // Reg exp to find open tag + content + close tag
+    fullMatchRegExpByTag,
+    // Reg exp to find opening tags
+    openTagsRegExp: new RegExp('(' + openTagsRegExp.join('|') + ')', 'g'),
+    transformersByTag
+  };
 }
 
 /**
@@ -860,385 +415,483 @@ function selectAfterFinalCaptureGroup(scanningContext, parentElementNode) {
  * 
  */
 
-function getTextNodeForAutoFormatting(selection) {
-  if (!lexical.$isRangeSelection(selection)) {
-    return null;
+function runElementTransformers(parentNode, anchorNode, anchorOffset, elementTransformers) {
+  const grandParentNode = parentNode.getParent();
+
+  if (!lexical.$isRootNode(grandParentNode) || parentNode.getFirstChild() !== anchorNode) {
+    return false;
   }
 
-  const node = selection.anchor.getNode();
+  const 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 (!lexical.$isTextNode(node)) {
-    return null;
+  if (textContent[anchorOffset - 1] !== ' ') {
+    return false;
   }
 
-  return {
-    node,
-    offset: selection.anchor.offset
-  };
-}
+  for (const {
+    regExp,
+    replace
+  } of elementTransformers) {
+    const match = textContent.match(regExp);
 
-function updateAutoFormatting(editor, scanningContext, createHorizontalRuleNode) {
-  editor.update(() => {
-    const elementNode = getTextNodeWithOffsetOrThrow(scanningContext).node.getParentOrThrow();
-    transformTextNodeForMarkdownCriteria(scanningContext, elementNode, createHorizontalRuleNode);
-  }, {
-    tag: 'history-push'
-  });
+    if (match && match[0].length === anchorOffset) {
+      const nextSiblings = anchorNode.getNextSiblings();
+      const [leadingNode, remainderNode] = anchorNode.splitText(anchorOffset);
+      leadingNode.remove();
+      const siblings = remainderNode ? [remainderNode, ...nextSiblings] : nextSiblings;
+      replace(parentNode, siblings, match, false);
+      return true;
+    }
+  }
+
+  return false;
 }
 
-function getCriteriaWithPatternMatchResults(markdownCriteriaArray, scanningContext) {
-  const currentTriggerState = scanningContext.triggerState;
-  const count = markdownCriteriaArray.length;
+function runTextMatchTransformers(anchorNode, anchorOffset, transformersByTrigger) {
+  let textContent = anchorNode.getTextContent();
+  const lastChar = textContent[anchorOffset - 1];
+  const transformers = transformersByTrigger[lastChar];
 
-  for (let i = 0; i < count; i++) {
-    const markdownCriteria = markdownCriteriaArray[i]; // Skip code block nodes, unless the autoFormatKind calls for toggling the code block.
+  if (transformers == null) {
+    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 (currentTriggerState != null && currentTriggerState.isCodeBlock === false || markdownCriteria.markdownFormatKind === 'paragraphCodeBlock') {
-      const patternMatchResults = getPatternMatchResultsForCriteria(markdownCriteria, scanningContext, getParentElementNodeOrThrow(scanningContext));
 
-      if (patternMatchResults != null) {
-        return {
-          markdownCriteria,
-          patternMatchResults
-        };
-      }
-    }
+  if (anchorOffset < textContent.length) {
+    textContent = textContent.slice(0, anchorOffset);
   }
 
-  return {
-    markdownCriteria: null,
-    patternMatchResults: null
-  };
-}
-
-function findScanningContextWithValidMatch(editor, currentTriggerState) {
-  let scanningContext = null;
-  editor.getEditorState().read(() => {
-    const textNodeWithOffset = getTextNodeForAutoFormatting(lexical.$getSelection());
-
-    if (textNodeWithOffset === null) {
-      return;
-    } // Please see the declaration of ScanningContext for a detailed explanation.
+  for (const transformer of transformers) {
+    const match = textContent.match(transformer.regExp);
 
+    if (match === null) {
+      continue;
+    }
 
-    const initialScanningContext = getInitialScanningContext(editor, true, textNodeWithOffset, currentTriggerState);
-    const criteriaWithPatternMatchResults = getCriteriaWithPatternMatchResults( // Do not apply paragraph node changes like blockQuote or H1 to listNodes. Also, do not attempt to transform a list into a list using * or -.
-    currentTriggerState.isParentAListItemNode === false ? getAllMarkdownCriteria() : getAllMarkdownCriteriaForTextNodes(), initialScanningContext);
+    const startIndex = match.index;
+    const endIndex = startIndex + match[0].length;
+    let replaceNode;
 
-    if (criteriaWithPatternMatchResults.markdownCriteria === null || criteriaWithPatternMatchResults.patternMatchResults === null) {
-      return;
+    if (startIndex === 0) {
+      [replaceNode] = anchorNode.splitText(endIndex);
+    } else {
+      [, replaceNode] = anchorNode.splitText(startIndex, endIndex);
     }
 
-    scanningContext = initialScanningContext; // Lazy fill-in the particular format criteria and any matching result information.
+    replaceNode.selectNext();
+    transformer.replace(replaceNode, match);
+    return true;
+  }
 
-    scanningContext.markdownCriteria = criteriaWithPatternMatchResults.markdownCriteria;
-    scanningContext.patternMatchResults = criteriaWithPatternMatchResults.patternMatchResults;
-  });
-  return scanningContext;
+  return false;
 }
 
-function getTriggerState(editorState) {
-  let criteria = null;
-  editorState.read(() => {
-    const selection = lexical.$getSelection();
+function runTextFormatTransformers(editor, anchorNode, anchorOffset, textFormatTransformers) {
+  const textContent = anchorNode.getTextContent();
+  const closeTagEndIndex = anchorOffset - 1;
+  const closeChar = textContent[closeTagEndIndex]; // Quick check if we're possibly at the end of inline markdown style
 
-    if (!lexical.$isRangeSelection(selection) || !selection.isCollapsed()) {
-      return;
-    }
+  const matchers = textFormatTransformers[closeChar];
 
-    const node = selection.anchor.getNode();
-    const parentNode = node.getParent();
-    const isParentAListItemNode = list.$isListItemNode(parentNode);
-    const hasParentNode = parentNode !== null;
-    criteria = {
-      anchorOffset: selection.anchor.offset,
-      hasParentNode,
-      isCodeBlock: code.$isCodeNode(node),
-      isParentAListItemNode,
-      isSelectionCollapsed: true,
-      isSimpleText: lexical.$isTextNode(node) && node.isSimpleText(),
-      nodeKey: node.getKey(),
-      textContent: node.getTextContent()
-    };
-  });
-  return criteria;
-}
-function findScanningContext(editor, currentTriggerState, priorTriggerState) {
-  if (currentTriggerState == null || priorTriggerState == null) {
-    return null;
+  if (!matchers) {
+    return false;
   }
 
-  const triggerArray = getAllTriggers();
-  const triggerCount = triggers.length;
+  for (const matcher of matchers) {
+    const {
+      tag
+    } = matcher;
+    const tagLength = tag.length;
+    const closeTagStartIndex = closeTagEndIndex - tagLength + 1; // If tag is not single char check if rest of it matches with text content
 
-  for (let ti = 0; ti < triggerCount; ti++) {
-    const triggerString = triggerArray[ti].triggerString; // The below checks needs to execute relativey quickly, so perform the light-weight ones first.
-    // The substr check is a quick way to avoid autoformat parsing in that it looks for the autoformat
-    // trigger which is the trigger string (" ").
+    if (tagLength > 1) {
+      if (!isEqualSubString(textContent, closeTagStartIndex, tag, 0, tagLength)) {
+        continue;
+      }
+    } // Space before closing tag cancels inline markdown
 
-    const triggerStringLength = triggerString.length;
-    const currentTextContentLength = currentTriggerState.textContent.length;
-    const triggerOffset = currentTriggerState.anchorOffset - triggerStringLength; // Todo: these checks help w/ performance, yet we can do more.
-    // We might consider looking for ** + space or __ + space and so on to boost performance
-    // even further. Make sure the patter is driven from the trigger state type.
 
-    if ((currentTriggerState.hasParentNode === true && currentTriggerState.isSimpleText && currentTriggerState.isSelectionCollapsed && currentTriggerState.anchorOffset !== priorTriggerState.anchorOffset && triggerOffset >= 0 && triggerOffset + triggerStringLength <= currentTextContentLength && currentTriggerState.textContent.substr(triggerOffset, triggerStringLength) === triggerString && // Some code differentiation needed if trigger kind is not a simple space character.
-    currentTriggerState.textContent !== priorTriggerState.textContent) === false) {
-      return null;
+    if (textContent[closeTagStartIndex - 1] === ' ') {
+      continue;
     }
-  }
 
-  return findScanningContextWithValidMatch(editor, currentTriggerState);
-}
+    const closeNode = anchorNode;
+    let openNode = closeNode;
+    let 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
 
-/**
- * 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.
- *
- * 
- */
-function convertStringToLexical(text, editor) {
-  if (!text.length) {
-    return null;
-  }
+    let sibling = openNode;
 
-  const nodes = [];
-  const splitLines = text.split('\n');
-  const splitLinesCount = splitLines.length;
+    while (openTagStartIndex < 0 && (sibling = sibling.getPreviousSibling())) {
+      if (lexical.$isLineBreakNode(sibling)) {
+        break;
+      }
 
-  for (let i = 0; i < splitLinesCount; i++) {
-    if (splitLines[i].length > 0) {
-      nodes.push(lexical.$createParagraphNode().append(lexical.$createTextNode(splitLines[i])));
-    } else {
-      nodes.push(lexical.$createParagraphNode());
-    }
-  }
+      if (lexical.$isTextNode(sibling)) {
+        const siblingTextContent = sibling.getTextContent();
+        openNode = sibling;
+        openTagStartIndex = getOpenTagStartIndex(siblingTextContent, siblingTextContent.length, tag);
+      }
+    } // Opening tag is not found
 
-  if (nodes.length) {
-    const root = lexical.$getRoot();
-    root.clear();
-    root.append(...nodes);
-    return root;
-  }
 
-  return null;
-}
-function convertMarkdownForElementNodes(editor, createHorizontalRuleNode) {
-  // Please see the declaration of ScanningContext for a detailed explanation.
-  const scanningContext = getInitialScanningContext(editor, false, null, null);
-  const root = lexical.$getRoot();
-  let done = false;
-  let startIndex = 0; // Handle the paragraph level markdown.
+    if (openTagStartIndex < 0) {
+      continue;
+    } // No content between opening and closing tag
 
-  while (!done) {
-    done = true;
-    const elementNodes = root.getChildren();
-    const countOfElementNodes = elementNodes.length;
 
-    for (let i = startIndex; i < countOfElementNodes; i++) {
-      const elementNode = elementNodes[i];
+    if (openNode === closeNode && openTagStartIndex + tagLength === closeTagStartIndex) {
+      continue;
+    } // Checking longer tags for repeating chars (e.g. *** vs **)
 
-      if (lexical.$isElementNode(elementNode)) {
-        convertParagraphLevelMarkdown(scanningContext, elementNode, createHorizontalRuleNode);
-      } // Reset the scanning information that relates to the particular element node.
 
+    const prevOpenNodeText = openNode.getTextContent();
 
-      resetScanningContext(scanningContext);
+    if (openTagStartIndex > 0 && prevOpenNodeText[openTagStartIndex - 1] === closeChar) {
+      continue;
+    } // Clean text from opening and closing tags (starting from closing tag
+    // to prevent any offset shifts if we start from opening one)
 
-      if (root.getChildren().length !== countOfElementNodes) {
-        // The conversion added or removed an from root's children.
-        startIndex = i;
-        done = false;
-        break;
+
+    const prevCloseNodeText = closeNode.getTextContent();
+    const closeNodeText = prevCloseNodeText.slice(0, closeTagStartIndex) + prevCloseNodeText.slice(closeTagEndIndex + 1);
+    closeNode.setTextContent(closeNodeText);
+    const openNodeText = openNode === closeNode ? closeNodeText : prevOpenNodeText;
+    openNode.setTextContent(openNodeText.slice(0, openTagStartIndex) + openNodeText.slice(openTagStartIndex + tagLength));
+    const nextSelection = lexical.$createRangeSelection();
+    lexical.$setSelection(nextSelection); // Adjust offset based on deleted chars
+
+    const 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
+
+    for (const format of matcher.format) {
+      if (!nextSelection.hasFormat(format)) {
+        nextSelection.formatText(format);
       }
-    }
-  } // while
+    } // Collapse selection up to the focus point
 
 
-  done = false;
-  startIndex = 0; // Handle the text level markdown.
+    nextSelection.anchor.set(nextSelection.focus.key, nextSelection.focus.offset, nextSelection.focus.type); // Remove formatting from collapsed selection
 
-  while (!done) {
-    done = true;
-    const elementNodes = root.getChildren();
-    const countOfElementNodes = elementNodes.length;
+    for (const format of matcher.format) {
+      if (nextSelection.hasFormat(format)) {
+        nextSelection.toggleFormat(format);
+      }
+    }
 
-    for (let i = startIndex; i < countOfElementNodes; i++) {
-      const elementNode = elementNodes[i];
+    return true;
+  }
 
-      if (lexical.$isElementNode(elementNode)) {
-        convertTextLevelMarkdown(scanningContext, elementNode, createHorizontalRuleNode);
-      } // Reset the scanning information that relates to the particular element node.
+  return false;
+}
 
+function getOpenTagStartIndex(string, maxIndex, tag) {
+  const tagLength = tag.length;
 
-      resetScanningContext(scanningContext);
+  for (let i = maxIndex; i >= tagLength; i--) {
+    const startIndex = i - tagLength;
+
+    if (isEqualSubString(string, startIndex, tag, 0, tagLength) && // Space after opening tag cancels transformation
+    string[startIndex + tagLength] !== ' ') {
+      return startIndex;
     }
-  } // while
+  }
 
+  return -1;
 }
 
-function convertParagraphLevelMarkdown(scanningContext, elementNode, createHorizontalRuleNode) {
-  const textContent = elementNode.getTextContent(); // Handle paragraph nodes below.
-
-  if (lexical.$isParagraphNode(elementNode)) {
-    const paragraphNode = elementNode;
-    const firstChild = paragraphNode.getFirstChild();
-    const firstChildIsTextNode = lexical.$isTextNode(firstChild); // Handle conversion to code block.
-
-    if (scanningContext.isWithinCodeBlock === true) {
-      if (firstChild != null && firstChildIsTextNode) {
-        // Test if we encounter ending code block.
-        scanningContext.textNodeWithOffset = {
-          node: firstChild,
-          offset: 0
-        };
-        const patternMatchResults = getPatternMatchResultsForCodeBlock(scanningContext, textContent);
-
-        if (patternMatchResults != null) {
-          // Toggle transform to or from code block.
-          scanningContext.patternMatchResults = patternMatchResults;
-        }
-      }
+function isEqualSubString(stringA, aStart, stringB, bStart, length) {
+  for (let i = 0; i < length; i++) {
+    if (stringA[aStart + i] !== stringB[bStart + i]) {
+      return false;
+    }
+  }
 
-      scanningContext.markdownCriteria = getCodeBlockCriteria(); // Perform text transformation here.
+  return true;
+}
 
-      transformTextNodeForMarkdownCriteria(scanningContext, elementNode, createHorizontalRuleNode);
+function registerMarkdownShortcuts(editor, transformers = TRANSFORMERS) {
+  const byType = transformersByType(transformers);
+  const textFormatTransformersIndex = indexBy(byType.textFormat, ({
+    tag
+  }) => tag[tag.length - 1]);
+  const textMatchTransformersIndex = indexBy(byType.textMatch, ({
+    trigger
+  }) => trigger);
+
+  const transform = (parentNode, anchorNode, anchorOffset) => {
+    if (runElementTransformers(parentNode, anchorNode, anchorOffset, byType.element)) {
       return;
     }
 
-    if (elementNode.getChildren().length) {
-      const allCriteria = getAllMarkdownCriteriaForParagraphs();
-      const count = allCriteria.length;
-      scanningContext.joinedText = paragraphNode.getTextContent();
+    if (runTextMatchTransformers(anchorNode, anchorOffset, textMatchTransformersIndex)) {
+      return;
+    }
 
-      if (!(firstChild != null && firstChildIsTextNode)) {
-        throw Error(`Expect paragraph containing only text nodes.`);
-      }
+    runTextFormatTransformers(editor, anchorNode, anchorOffset, textFormatTransformersIndex);
+  };
 
-      scanningContext.textNodeWithOffset = {
-        node: firstChild,
-        offset: 0
-      };
+  return editor.registerUpdateListener(({
+    tags,
+    dirtyLeaves,
+    editorState,
+    prevEditorState
+  }) => {
+    // Ignore updates from undo/redo (as changes already calculated)
+    if (tags.has('historic')) {
+      return;
+    }
 
-      for (let i = 0; i < count; i++) {
-        const criteria = allCriteria[i];
+    const selection = editorState.read(lexical.$getSelection);
+    const prevSelection = prevEditorState.read(lexical.$getSelection);
 
-        if (criteria.requiresParagraphStart === false) {
-          return;
-        }
+    if (!lexical.$isRangeSelection(prevSelection) || !lexical.$isRangeSelection(selection) || !selection.isCollapsed()) {
+      return;
+    }
 
-        const patternMatchResults = getPatternMatchResultsForCriteria(criteria, scanningContext, getParentElementNodeOrThrow(scanningContext));
+    const anchorKey = selection.anchor.key;
+    const anchorOffset = selection.anchor.offset;
 
-        if (patternMatchResults != null) {
-          scanningContext.markdownCriteria = criteria;
-          scanningContext.patternMatchResults = patternMatchResults; // Perform text transformation here.
+    const anchorNode = editorState._nodeMap.get(anchorKey);
 
-          transformTextNodeForMarkdownCriteria(scanningContext, elementNode, createHorizontalRuleNode);
-          return;
-        }
-      }
+    if (!lexical.$isTextNode(anchorNode) || !dirtyLeaves.has(anchorKey) || anchorOffset !== 1 && anchorOffset !== prevSelection.anchor.offset + 1) {
+      return;
     }
-  }
-}
-
-function convertTextLevelMarkdown(scanningContext, elementNode, createHorizontalRuleNode) {
-  const firstChild = elementNode.getFirstChild();
-
-  if (lexical.$isTextNode(firstChild)) {
-    // This function will convert all text nodes within the elementNode.
-    convertMarkdownForTextCriteria(scanningContext, elementNode, createHorizontalRuleNode);
-    return;
-  } // Handle the case where the elementNode has child elementNodes like lists.
-  // Since we started at a text import, we don't need to worry about anything but textNodes.
 
+    editor.update(() => {
+      // Markdown is not available inside code
+      if (anchorNode.hasFormat('code')) {
+        return;
+      }
 
-  const children = elementNode.getChildren();
-  const countOfChildren = children.length;
+      const parentNode = anchorNode.getParent();
 
-  for (let i = 0; i < countOfChildren; i++) {
-    const node = children[i];
+      if (parentNode === null || code.$isCodeNode(parentNode)) {
+        return;
+      }
 
-    if (lexical.$isElementNode(node)) {
-      // Recurse down until we find a text node.
-      convertTextLevelMarkdown(scanningContext, node, createHorizontalRuleNode);
-    }
-  }
+      transform(parentNode, anchorNode, selection.anchor.offset);
+    });
+  });
 }
 
-function convertMarkdownForTextCriteria(scanningContext, elementNode, createHorizontalRuleNode) {
-  resetScanningContext(scanningContext); // Cycle through all the criteria and convert all text patterns in the parent element.
+/**
+ * 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.
+ *
+ * 
+ */
 
-  const allCriteria = getAllMarkdownCriteriaForTextNodes();
-  const count = allCriteria.length;
-  let textContent = elementNode.getTextContent();
-  let done = textContent.length === 0;
-  let startIndex = 0;
+const replaceWithBlock = createNode => {
+  return (parentNode, children, match) => {
+    const node = createNode(match);
+    node.append(...children);
+    parentNode.replace(node);
+    node.select(0, 0);
+  };
+}; // Amount of spaces that define indentation level
+// TODO: should be an option
 
-  while (!done) {
-    done = true;
 
-    for (let i = startIndex; i < count; i++) {
-      const criteria = allCriteria[i];
+const LIST_INDENT_SIZE = 4;
 
-      if (scanningContext.textNodeWithOffset == null) {
-        // Need to search through the very last text node in the element.
-        const lastTextNode = getLastTextNodeInElementNode(elementNode);
+const listReplace = listType => {
+  return (parentNode, children, match) => {
+    const previousNode = parentNode.getPreviousSibling();
+    const listItem = list.$createListItemNode(listType === 'check' ? match[3] === 'x' : undefined);
 
-        if (lastTextNode == null) {
-          // If we have no more text nodes, then there's nothing to search and transform.
-          return;
-        }
+    if (list.$isListNode(previousNode) && previousNode.getListType() === listType) {
+      previousNode.append(listItem);
+      parentNode.remove();
+    } else {
+      const list$1 = list.$createListNode(listType, listType === 'number' ? Number(match[2]) : undefined);
+      list$1.append(listItem);
+      parentNode.replace(list$1);
+    }
 
-        scanningContext.textNodeWithOffset = {
-          node: lastTextNode,
-          offset: lastTextNode.getTextContent().length
-        };
-      }
+    listItem.append(...children);
+    listItem.select(0, 0);
+    const indent = Math.floor(match[1].length / LIST_INDENT_SIZE);
 
-      const patternMatchResults = getPatternMatchResultsForCriteria(criteria, scanningContext, elementNode);
+    if (indent) {
+      listItem.setIndent(indent);
+    }
+  };
+};
 
-      if (patternMatchResults != null) {
-        scanningContext.markdownCriteria = criteria;
-        scanningContext.patternMatchResults = patternMatchResults; // Perform text transformation here.
+const listExport = (listNode, exportChildren, depth) => {
+  const output = [];
+  const children = listNode.getChildren();
+  let index = 0;
 
-        transformTextNodeForMarkdownCriteria(scanningContext, elementNode, createHorizontalRuleNode);
-        resetScanningContext(scanningContext);
-        const currentTextContent = elementNode.getTextContent();
+  for (const listItemNode of children) {
+    if (list.$isListItemNode(listItemNode)) {
+      if (listItemNode.getChildrenSize() === 1) {
+        const firstChild = listItemNode.getFirstChild();
 
-        if (currentTextContent.length === 0) {
-          // Nothing left to convert.
-          return;
+        if (list.$isListNode(firstChild)) {
+          output.push(listExport(firstChild, exportChildren, depth + 1));
+          continue;
         }
+      }
 
-        if (currentTextContent === textContent) {
-          // Nothing was changed by this transformation, so move on to the next crieteria.
-          continue;
-        } // The text was changed. Perhaps there is another hit for the same criteria.
+      const indent = ' '.repeat(depth * LIST_INDENT_SIZE);
+      const listType = listNode.getListType();
+      const prefix = listType === 'number' ? `${listNode.getStart() + index}. ` : listType === 'check' ? `- [${listItemNode.getChecked() ? 'x' : ' '}] ` : '- ';
+      output.push(indent + prefix + exportChildren(listItemNode));
+      index++;
+    }
+  }
 
+  return output.join('\n');
+};
 
-        textContent = currentTextContent;
-        startIndex = i;
-        done = false;
-        break;
-      }
+const HEADING = {
+  export: (node, exportChildren) => {
+    if (!richText.$isHeadingNode(node)) {
+      return null;
     }
-  }
-}
 
-function getLastTextNodeInElementNode(elementNode) {
-  const children = elementNode.getChildren();
-  const countOfChildren = children.length;
+    const level = Number(node.getTag().slice(1));
+    return '#'.repeat(level) + ' ' + exportChildren(node);
+  },
+  regExp: /^(#{1,6})\s/,
+  replace: replaceWithBlock(match => {
+    // $FlowFixMe[incompatible-cast]
+    const tag = 'h' + match[1].length;
+    return richText.$createHeadingNode(tag);
+  }),
+  type: 'element'
+};
+const QUOTE = {
+  export: (node, exportChildren) => {
+    return richText.$isQuoteNode(node) ? '> ' + exportChildren(node) : null;
+  },
+  regExp: /^>\s/,
+  replace: replaceWithBlock(() => richText.$createQuoteNode()),
+  type: 'element'
+};
+const CODE = {
+  export: node => {
+    if (!code.$isCodeNode(node)) {
+      return null;
+    }
 
-  for (let i = countOfChildren - 1; i >= 0; i--) {
-    if (lexical.$isTextNode(children[i])) {
-      return children[i];
+    const textContent = node.getTextContent();
+    return '```' + (node.getLanguage() || '') + (textContent ? '\n' + textContent : '') + '\n' + '```';
+  },
+  regExp: /^```(\w{1,10})?\s/,
+  replace: replaceWithBlock(match => {
+    return code.$createCodeNode(match ? match[1] : undefined);
+  }),
+  type: 'element'
+};
+const UNORDERED_LIST = {
+  export: (node, exportChildren) => {
+    return list.$isListNode(node) ? listExport(node, exportChildren, 0) : null;
+  },
+  regExp: /^(\s*)[-*+]\s/,
+  replace: listReplace('bullet'),
+  type: 'element'
+};
+const CHECK_LIST = {
+  export: (node, exportChildren) => {
+    return list.$isListNode(node) ? listExport(node, exportChildren, 0) : null;
+  },
+  regExp: /^(\s*)(?:-\s)?\s?(\[(\s|x)?\])\s/i,
+  replace: listReplace('check'),
+  type: 'element'
+};
+const ORDERED_LIST = {
+  export: (node, exportChildren) => {
+    return list.$isListNode(node) ? listExport(node, exportChildren, 0) : null;
+  },
+  regExp: /^(\s*)(\d{1,})\.\s/,
+  replace: listReplace('number'),
+  type: 'element'
+};
+const INLINE_CODE = {
+  format: ['code'],
+  tag: '`',
+  type: 'text-format'
+};
+const BOLD_ITALIC_STAR = {
+  format: ['bold', 'italic'],
+  tag: '***',
+  type: 'text-format'
+};
+const BOLD_ITALIC_UNDERSCORE = {
+  format: ['bold', 'italic'],
+  tag: '___',
+  type: 'text-format'
+};
+const BOLD_STAR = {
+  format: ['bold'],
+  tag: '**',
+  type: 'text-format'
+};
+const BOLD_UNDERSCORE = {
+  format: ['bold'],
+  tag: '__',
+  type: 'text-format'
+};
+const STRIKETHROUGH = {
+  format: ['strikethrough'],
+  tag: '~~',
+  type: 'text-format'
+};
+const ITALIC_STAR = {
+  format: ['italic'],
+  tag: '*',
+  type: 'text-format'
+};
+const ITALIC_UNDERSCORE = {
+  format: ['italic'],
+  tag: '_',
+  type: 'text-format'
+}; // Order of text transformers matters:
+//
+// - code should go first as it prevents any transformations inside
+// - then longer tags match (e.g. ** or __ should go before * or _)
+
+const LINK = {
+  export: (node, exportChildren, exportFormat) => {
+    if (!link.$isLinkNode(node)) {
+      return null;
     }
-  }
 
-  return null;
-}
+    const linkContent = `[${node.getTextContent()}](${node.getURL()})`;
+    const firstChild = node.getFirstChild(); // Add text styles only if link has single text node inside. If it's more
+    // then one we ignore it as markdown does not support nested styles for links
+
+    if (node.getChildrenSize() === 1 && lexical.$isTextNode(firstChild)) {
+      return exportFormat(firstChild, linkContent);
+    } else {
+      return linkContent;
+    }
+  },
+  importRegExp: /(?:\[([^[]+)\])(?:\(([^(]+)\))/,
+  regExp: /(?:\[([^[]+)\])(?:\(([^(]+)\))$/,
+  replace: (textNode, match) => {
+    const [, linkText, linkUrl] = match;
+    const linkNode = link.$createLinkNode(linkUrl);
+    const linkTextNode = lexical.$createTextNode(linkText);
+    linkTextNode.setFormat(textNode.getFormat());
+    linkNode.append(linkTextNode);
+    textNode.replace(linkNode);
+  },
+  trigger: ')',
+  type: 'text-match'
+};
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -1248,35 +901,44 @@ function getLastTextNodeInElementNode(elementNode) {
  *
  * 
  */
-function registerMarkdownShortcuts(editor, createHorizontalRuleNode) {
-  // The priorTriggerState is compared against the currentTriggerState to determine
-  // if the user has performed some typing event that warrants an auto format.
-  // For example, typing "#" and then " ", shoud trigger an format.
-  // However, given "#A B", where the user delets "A" should not.
-  let priorTriggerState = null;
-  return editor.registerUpdateListener(({
-    tags
-  }) => {
-    // Examine historic so that we are not running autoformatting within markdown.
-    if (tags.has('historic') === false) {
-      const currentTriggerState = getTriggerState(editor.getEditorState());
-      const scanningContext = currentTriggerState == null ? null : findScanningContext(editor, currentTriggerState, priorTriggerState);
+const ELEMENT_TRANSFORMERS = [HEADING, QUOTE, CODE, UNORDERED_LIST, ORDERED_LIST]; // Order of text format transformers matters:
+//
+// - code should go first as it prevents any transformations inside
+// - then longer tags match (e.g. ** or __ should go before * or _)
 
-      if (scanningContext != null) {
-        updateAutoFormatting(editor, scanningContext, createHorizontalRuleNode);
-      }
+const TEXT_FORMAT_TRANSFORMERS = [INLINE_CODE, BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, ITALIC_STAR, ITALIC_UNDERSCORE, STRIKETHROUGH];
+const TEXT_MATCH_TRANSFORMERS = [LINK];
+const TRANSFORMERS = [...ELEMENT_TRANSFORMERS, ...TEXT_FORMAT_TRANSFORMERS, ...TEXT_MATCH_TRANSFORMERS];
 
-      priorTriggerState = currentTriggerState;
-    } else {
-      priorTriggerState = null;
-    }
-  });
+function $convertFromMarkdownString(markdown, transformers = TRANSFORMERS) {
+  const importMarkdown = createMarkdownImport(transformers);
+  return importMarkdown(markdown);
 }
-function $convertFromMarkdownString(markdownString, editor, createHorizontalRuleNode) {
-  if (convertStringToLexical(markdownString) != null) {
-    convertMarkdownForElementNodes(editor, createHorizontalRuleNode);
-  }
+
+function $convertToMarkdownString(transformers = TRANSFORMERS) {
+  const exportMarkdown = createMarkdownExport(transformers);
+  return exportMarkdown();
 }
 
 exports.$convertFromMarkdownString = $convertFromMarkdownString;
+exports.$convertToMarkdownString = $convertToMarkdownString;
+exports.BOLD_ITALIC_STAR = BOLD_ITALIC_STAR;
+exports.BOLD_ITALIC_UNDERSCORE = BOLD_ITALIC_UNDERSCORE;
+exports.BOLD_STAR = BOLD_STAR;
+exports.BOLD_UNDERSCORE = BOLD_UNDERSCORE;
+exports.CHECK_LIST = CHECK_LIST;
+exports.CODE = CODE;
+exports.ELEMENT_TRANSFORMERS = ELEMENT_TRANSFORMERS;
+exports.HEADING = HEADING;
+exports.INLINE_CODE = INLINE_CODE;
+exports.ITALIC_STAR = ITALIC_STAR;
+exports.ITALIC_UNDERSCORE = ITALIC_UNDERSCORE;
+exports.LINK = LINK;
+exports.ORDERED_LIST = ORDERED_LIST;
+exports.QUOTE = QUOTE;
+exports.STRIKETHROUGH = STRIKETHROUGH;
+exports.TEXT_FORMAT_TRANSFORMERS = TEXT_FORMAT_TRANSFORMERS;
+exports.TEXT_MATCH_TRANSFORMERS = TEXT_MATCH_TRANSFORMERS;
+exports.TRANSFORMERS = TRANSFORMERS;
+exports.UNORDERED_LIST = UNORDERED_LIST;
 exports.registerMarkdownShortcuts = registerMarkdownShortcuts;