@lexical/markdown 0.1.21 → 0.2.2

package/LexicalMarkdown.dev.js

@@ -41,7 +41,7 @@ const SEPARATOR_LENGTH = SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES.length;
 const spaceTrigger = {
   triggerKind: 'space_trigger',
   triggerString: '\u0020'
-}; // TODO: add support for ``` + carriage return either inside or not inside code block. Should toggle between.
+}; // 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.
@@ -49,7 +49,7 @@ const spaceTrigger = {
 
 const triggers = [spaceTrigger
 /*, codeBlockTrigger*/
-]; // Todo: speed up performance by having non-capture group variations of the regex.
+]; // Future Todo: speed up performance by having non-capture group variations of the regex.
 
 const autoFormatBase = {
   markdownFormatKind: null,
@@ -62,33 +62,43 @@ const paragraphStartBase = { ...autoFormatBase,
 };
 const markdownHeader1 = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphH1',
-  regEx: /^(?:#)/,
+  regEx: /^(?:# )/,
   regExForAutoFormatting: /^(?:# )/
 };
 const markdownHeader2 = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphH2',
-  regEx: /^(?:##)/,
+  regEx: /^(?:## )/,
   regExForAutoFormatting: /^(?:## )/
 };
 const markdownHeader3 = { ...paragraphStartBase,
-  markdownFormatKind: 'paragraphH2',
-  regEx: /^(?:###)/,
+  markdownFormatKind: 'paragraphH3',
+  regEx: /^(?:### )/,
   regExForAutoFormatting: /^(?:### )/
 };
+const markdownHeader4 = { ...paragraphStartBase,
+  markdownFormatKind: 'paragraphH4',
+  regEx: /^(?:#### )/,
+  regExForAutoFormatting: /^(?:#### )/
+};
+const markdownHeader5 = { ...paragraphStartBase,
+  markdownFormatKind: 'paragraphH5',
+  regEx: /^(?:##### )/,
+  regExForAutoFormatting: /^(?:##### )/
+};
 const markdownBlockQuote = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphBlockQuote',
-  regEx: /^(?:>)/,
+  regEx: /^(?:> )/,
   regExForAutoFormatting: /^(?:> )/
 };
 const markdownUnorderedListDash = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphUnorderedList',
-  regEx: /^(?:- )/,
-  regExForAutoFormatting: /^(?:- )/
+  regEx: /^(\s{0,10})(?:- )/,
+  regExForAutoFormatting: /^(\s{0,10})(?:- )/
 };
 const markdownUnorderedListAsterisk = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphUnorderedList',
-  regEx: /^(?:\* )/,
-  regExForAutoFormatting: /^(?:\* )/
+  regEx: /^(\s{0,10})(?:\* )/,
+  regExForAutoFormatting: /^(\s{0,10})(?:\* )/
 };
 const markdownCodeBlock = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphCodeBlock',
@@ -97,8 +107,8 @@ const markdownCodeBlock = { ...paragraphStartBase,
 };
 const markdownOrderedList = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphOrderedList',
-  regEx: /^(\d+)\.\s/,
-  regExForAutoFormatting: /^(\d+)\.\s/
+  regEx: /^(\s{0,10})(\d+)\.\s/,
+  regExForAutoFormatting: /^(\s{0,10})(\d+)\.\s/
 };
 const markdownHorizontalRule = { ...paragraphStartBase,
   markdownFormatKind: 'horizontalRule',
@@ -110,45 +120,89 @@ const markdownHorizontalRuleUsingDashes = { ...paragraphStartBase,
   regEx: /^(?:---)$/,
   regExForAutoFormatting: /^(?:--- )/
 };
-const markdownItalic = { ...autoFormatBase,
-  markdownFormatKind: 'italic',
-  regEx: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*)/,
-  regExForAutoFormatting: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*)(\s)$/
+const markdownInlineCode = { ...autoFormatBase,
+  markdownFormatKind: 'code',
+  regEx: /(`)([^`]*)(`)/,
+  regExForAutoFormatting: /(`)(\s*\b)([^`]*)(\b\s*)(`)(\s)$/
 };
 const markdownBold = { ...autoFormatBase,
   markdownFormatKind: 'bold',
-  regEx: /(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)/,
+  regEx: /(\*\*)(\s*)([^\*\*]*)(\s*)(\*\*)()/,
   regExForAutoFormatting: /(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)(\s)$/
 };
-const markdownBoldWithUnderlines = { ...autoFormatBase,
+const markdownItalic = { ...autoFormatBase,
+  markdownFormatKind: 'italic',
+  regEx: /(\*)(\s*)([^\*]*)(\s*)(\*)()/,
+  regExForAutoFormatting: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*)(\s)$/
+};
+const markdownBold2 = { ...autoFormatBase,
   markdownFormatKind: 'bold',
-  regEx: /(__)(\s*)([^__]*)(\s*)(__)/,
+  regEx: /(__)(\s*)([^__]*)(\s*)(__)()/,
   regExForAutoFormatting: /(__)(\s*)([^__]*)(\s*)(__)(\s)$/
 };
-const markdownBoldItalic = { ...autoFormatBase,
-  markdownFormatKind: 'bold_italic',
-  regEx: /(\*\*\*)(\s*\b)([^\*\*\*]*)(\b\s*)(\*\*\*)/,
-  regExForAutoFormatting: /(\*\*\*)(\s*\b)([^\*\*\*]*)(\b\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*\b)([^\<]*)(\b\s*)(\<\/u\>)/,
+  regEx: /(\<u\>)(\s*)([^\<]*)(\s*)(\<\/u\>)()/,
   regExForAutoFormatting: /(\<u\>)(\s*\b)([^\<]*)(\b\s*)(\<\/u\>)(\s)$/
 };
 const markdownStrikethrough = { ...autoFormatBase,
   markdownFormatKind: 'strikethrough',
-  regEx: /(~~)(\s*\b)([^~~]*)(\b\s*)(~~)/,
+  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)$/
+  regEx: /(\[)([^\]]*)(\]\()([^)]*)(\)*)()/,
+  regExForAutoFormatting: /(\[)([^\]]*)(\]\()([^)]*)(\)*)(\s)$/
 };
-const allMarkdownCriteriaForTextNodes = [markdownBoldItalic, markdownItalic, markdownBold, markdownBoldWithUnderlines, fakeMarkdownUnderline, markdownStrikethrough, markdownLink];
-const allMarkdownCriteria = [markdownHeader1, markdownHeader2, markdownHeader3, markdownBlockQuote, markdownUnorderedListDash, markdownUnorderedListAsterisk, markdownOrderedList, markdownCodeBlock, markdownHorizontalRule, markdownHorizontalRuleUsingDashes, ...allMarkdownCriteriaForTextNodes];
+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 getInitialScanningContext(editor, isAutoFormatting, textNodeWithOffset, triggerState) {
   return {
     currentElementNode: null,
@@ -172,7 +226,7 @@ function getInitialScanningContext(editor, isAutoFormatting, textNodeWithOffset,
   };
 }
 function resetScanningContext(scanningContext) {
-  scanningContext.joinedText = '';
+  scanningContext.joinedText = null;
   scanningContext.markdownCriteria = {
     markdownFormatKind: 'noTransformation',
     regEx: /(?:)/,
@@ -191,6 +245,13 @@ function resetScanningContext(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);
@@ -226,6 +287,9 @@ function getPatternMatchResultsWithRegEx(textToSearch, matchMustAppearAtStartOfS
   return null;
 }
 
+function hasPatternMatchResults(scanningContext) {
+  return scanningContext.patternMatchResults.regExCaptureGroups.length > 0;
+}
 function getTextNodeWithOffsetOrThrow(scanningContext) {
   const textNodeWithOffset = scanningContext.textNodeWithOffset;
 
@@ -237,6 +301,7 @@ function getTextNodeWithOffsetOrThrow(scanningContext) {
 
   return textNodeWithOffset;
 }
+
 function getPatternMatchResultsForParagraphs(markdownCriteria, scanningContext) {
   const textNodeWithOffset = getTextNodeWithOffsetOrThrow(scanningContext); // At start of paragraph.
 
@@ -247,23 +312,23 @@ function getPatternMatchResultsForParagraphs(markdownCriteria, scanningContext)
 
   return null;
 }
-function getPatternMatchResultsForText(markdownCriteria, scanningContext) {
-  if (scanningContext.joinedText == null) {
-    const parentNode = getParent(scanningContext);
 
-    if (lexical.$isElementNode(parentNode)) {
+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(parentNode, SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES, getTextNodeWithOffsetOrThrow(scanningContext));
+        scanningContext.joinedText = text.$joinTextNodesInElementNode(parentElementNode, SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES, getTextNodeWithOffsetOrThrow(scanningContext));
       }
     } else {
       {
-        throw Error(`Expected node ${parentNode.__key} to to be a ElementNode.`);
+        throw Error(`Expected node ${parentElementNode.__key} to to be a ElementNode.`);
       }
     }
   }
 
-  return getPatternMatchResultsWithRegEx(scanningContext.joinedText, false, true, markdownCriteria.regExForAutoFormatting);
+  const matchMustAppearAtEndOfString = markdownCriteria.regExForAutoFormatting === true;
+  return getPatternMatchResultsWithRegEx(scanningContext.joinedText, false, matchMustAppearAtEndOfString, scanningContext.isAutoFormatting ? markdownCriteria.regExForAutoFormatting : markdownCriteria.regEx);
 }
 
 function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNode) {
@@ -305,9 +370,9 @@ function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNod
           };
         }
 
-      case 'paragraphBlockQuote':
+      case 'paragraphH4':
         {
-          newNode = richText.$createQuoteNode();
+          newNode = richText.$createHeadingNode('h4');
           newNode.append(...children);
           return {
             newNode,
@@ -315,37 +380,54 @@ function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNod
           };
         }
 
-      case 'paragraphUnorderedList':
+      case 'paragraphH5':
         {
-          newNode = list.$createListNode('ul');
-          const listItem = list.$createListItemNode();
-          listItem.append(...children);
-          newNode.append(listItem);
+          newNode = richText.$createHeadingNode('h5');
+          newNode.append(...children);
           return {
             newNode,
             shouldDelete
           };
         }
 
-      case 'paragraphOrderedList':
+      case 'paragraphBlockQuote':
         {
-          const startAsString = patternMatchResults.regExCaptureGroups.length > 1 ? patternMatchResults.regExCaptureGroups[patternMatchResults.regExCaptureGroups.length - 1].text : '1';
-          const start = parseInt(startAsString, 10);
-          newNode = list.$createListNode('ol', start);
-          const listItem = list.$createListItemNode();
-          listItem.append(...children);
-          newNode.append(listItem);
+          newNode = richText.$createQuoteNode();
+          newNode.append(...children);
           return {
             newNode,
             shouldDelete
           };
         }
 
+      case 'paragraphUnorderedList':
+        {
+          createListOrMergeWithPrevious(element, children, patternMatchResults, 'ul');
+          return {
+            newNode: null,
+            shouldDelete: 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
+          };
+        }
+
       case 'paragraphCodeBlock':
         {
           // Toggle code and paragraph nodes.
           if (scanningContext.isAutoFormatting === false) {
-            const shouldToggle = scanningContext.patternMatchResults.regExCaptureGroups.length > 0;
+            const shouldToggle = hasPatternMatchResults(scanningContext);
 
             if (shouldToggle) {
               scanningContext.isWithinCodeBlock = scanningContext.isWithinCodeBlock !== true; // When toggling, always clear the code block element node.
@@ -374,6 +456,11 @@ function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNod
                 const codeBlockNode = scanningContext.currentElementNode;
                 const lineBreakNode = lexical.$createLineBreakNode();
                 codeBlockNode.append(lineBreakNode);
+
+                if (children.length) {
+                  codeBlockNode.append(lineBreakNode);
+                }
+
                 codeBlockNode.append(...children);
               }
             }
@@ -421,18 +508,50 @@ function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNod
   };
 }
 
-function transformTextNodeForParagraphs(scanningContext, createHorizontalRuleNode) {
-  const textNodeWithOffset = getTextNodeWithOffsetOrThrow(scanningContext);
-  const element = textNodeWithOffset.node.getParentOrThrow();
+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
 
-  if (scanningContext.patternMatchResults.regExCaptureGroups.length > 0) {
-    const text = scanningContext.patternMatchResults.regExCaptureGroups[0].text; // Remove the text which we matched.
+  const prevElement = element.getPreviousSibling();
 
-    const textNode = textNodeWithOffset.node.spliceText(0, text.length, '', true);
+  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 (indent) {
+    listItem.setIndent(indent);
+  }
+}
 
-    if (textNode.getTextContent() === '') {
-      textNode.selectPrevious();
-      textNode.remove();
+function transformTextNodeForMarkdownCriteria(scanningContext, elementNode, createHorizontalRuleNode) {
+  if (scanningContext.markdownCriteria.requiresParagraphStart === true) {
+    transformTextNodeForElementNode(elementNode, scanningContext, createHorizontalRuleNode);
+  } else {
+    transformTextNodeForText(scanningContext, elementNode);
+  }
+}
+
+function transformTextNodeForElementNode(elementNode, scanningContext, createHorizontalRuleNode) {
+  if (scanningContext.textNodeWithOffset != null) {
+    const textNodeWithOffset = getTextNodeWithOffsetOrThrow(scanningContext);
+
+    if (hasPatternMatchResults(scanningContext)) {
+      const text = scanningContext.patternMatchResults.regExCaptureGroups[0].text; // Remove the text which we matched.
+
+      const textNode = textNodeWithOffset.node.spliceText(0, text.length, '', true);
+
+      if (textNode.getTextContent() === '') {
+        textNode.selectPrevious();
+        textNode.remove();
+      }
     }
   } // Transform the current element kind to the new element kind.
 
@@ -440,32 +559,33 @@ function transformTextNodeForParagraphs(scanningContext, createHorizontalRuleNod
   const {
     newNode,
     shouldDelete
-  } = getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNode);
+  } = getNewNodeForCriteria(scanningContext, elementNode, createHorizontalRuleNode);
 
   if (shouldDelete) {
-    element.remove();
+    elementNode.remove();
   } else if (newNode !== null) {
-    element.replace(newNode);
+    elementNode.replace(newNode);
   }
 }
-function transformTextNodeForText(scanningContext) {
+
+function transformTextNodeForText(scanningContext, parentElementNode) {
   const markdownCriteria = scanningContext.markdownCriteria;
 
   if (markdownCriteria.markdownFormatKind != null) {
     const formatting = getTextFormatType(markdownCriteria.markdownFormatKind);
 
     if (formatting != null) {
-      transformTextNodeWithFormatting(formatting, scanningContext);
+      transformTextNodeWithFormatting(formatting, scanningContext, parentElementNode);
       return;
     }
 
     if (markdownCriteria.markdownFormatKind === 'link') {
-      transformTextNodeWithLink(scanningContext);
+      transformTextNodeWithLink(scanningContext, parentElementNode);
     }
   }
 }
 
-function transformTextNodeWithFormatting(formatting, scanningContext) {
+function transformTextNodeWithFormatting(formatting, scanningContext, parentElementNode) {
   const patternMatchResults = scanningContext.patternMatchResults;
   const groupCount = patternMatchResults.regExCaptureGroups.length;
 
@@ -484,16 +604,16 @@ function transformTextNodeWithFormatting(formatting, scanningContext) {
   // Remove group 5.
 
 
-  removeTextByCaptureGroups(5, 5, scanningContext); // Remove group 1.
+  removeTextByCaptureGroups(5, 5, scanningContext, parentElementNode); // Remove group 1.
 
-  removeTextByCaptureGroups(1, 1, scanningContext); // Apply the formatting.
+  removeTextByCaptureGroups(1, 1, scanningContext, parentElementNode); // Apply the formatting.
 
-  formatTextInCaptureGroupIndex(formatting, 3, scanningContext); // Place caret at end of final capture group.
+  formatTextInCaptureGroupIndex(formatting, 3, scanningContext, parentElementNode); // Place caret at end of final capture group.
 
-  selectAfterFinalCaptureGroup(scanningContext);
+  selectAfterFinalCaptureGroup(scanningContext, parentElementNode);
 }
 
-function transformTextNodeWithLink(scanningContext) {
+function transformTextNodeWithLink(scanningContext, parentElementNode) {
   const patternMatchResults = scanningContext.patternMatchResults;
   const regExCaptureGroups = patternMatchResults.regExCaptureGroups;
   const groupCount = regExCaptureGroups.length;
@@ -519,10 +639,10 @@ function transformTextNodeWithLink(scanningContext) {
   } // Remove the initial pattern through to the final pattern.
 
 
-  removeTextByCaptureGroups(1, 5, scanningContext);
+  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);
-  const newSelectionForLink = createSelectionWithCaptureGroups(1, 1, false, true, scanningContext);
+  title, scanningContext, parentElementNode);
+  const newSelectionForLink = createSelectionWithCaptureGroups(1, 1, false, true, scanningContext, parentElementNode);
 
   if (newSelectionForLink == null) {
     return;
@@ -531,11 +651,11 @@ function transformTextNodeWithLink(scanningContext) {
   lexical.$setSelection(newSelectionForLink);
   scanningContext.editor.dispatchCommand(link.TOGGLE_LINK_COMMAND, url); // Place caret at end of final capture group.
 
-  selectAfterFinalCaptureGroup(scanningContext);
+  selectAfterFinalCaptureGroup(scanningContext, parentElementNode);
 } // Below are lower level helper functions.
 
 
-function getParent(scanningContext) {
+function getParentElementNodeOrThrow(scanningContext) {
   return getTextNodeWithOffsetOrThrow(scanningContext).node.getParentOrThrow();
 }
 
@@ -557,18 +677,34 @@ function getTextFormatType(markdownFormatKind) {
     case 'bold':
     case 'underline':
     case 'strikethrough':
+    case 'code':
       return [markdownFormatKind];
 
-    case 'bold_italic':
+    case 'strikethrough_italic_bold':
+      {
+        return ['strikethrough', 'italic', 'bold'];
+      }
+
+    case 'italic_bold':
+      {
+        return ['italic', 'bold'];
+      }
+
+    case 'strikethrough_italic':
+      {
+        return ['strikethrough', 'italic'];
+      }
+
+    case 'strikethrough_bold':
       {
-        return ['bold', 'italic'];
+        return ['strikethrough', 'bold'];
       }
   }
 
   return null;
 }
 
-function createSelectionWithCaptureGroups(anchorCaptureGroupIndex, focusCaptureGroupIndex, startAtEndOfAnchor, finishAtEndOfFocus, scanningContext) {
+function createSelectionWithCaptureGroups(anchorCaptureGroupIndex, focusCaptureGroupIndex, startAtEndOfAnchor, finishAtEndOfFocus, scanningContext, parentElementNode) {
   const patternMatchResults = scanningContext.patternMatchResults;
   const regExCaptureGroups = patternMatchResults.regExCaptureGroups;
   const regExCaptureGroupsCount = regExCaptureGroups.length;
@@ -577,7 +713,6 @@ function createSelectionWithCaptureGroups(anchorCaptureGroupIndex, focusCaptureG
     return null;
   }
 
-  const parentElementNode = getParent(scanningContext);
   const joinedTextLength = getJoinedTextLength(patternMatchResults);
   const anchorCaptureGroupDetail = regExCaptureGroups[anchorCaptureGroupIndex];
   const focusCaptureGroupDetail = regExCaptureGroups[focusCaptureGroupIndex];
@@ -586,6 +721,13 @@ function createSelectionWithCaptureGroups(anchorCaptureGroupIndex, focusCaptureG
   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 (anchorTextNodeWithOffset == null || focusTextNodeWithOffset == null) {
     return null;
   }
@@ -596,10 +738,10 @@ function createSelectionWithCaptureGroups(anchorCaptureGroupIndex, focusCaptureG
   return selection;
 }
 
-function removeTextByCaptureGroups(anchorCaptureGroupIndex, focusCaptureGroupIndex, scanningContext) {
+function removeTextByCaptureGroups(anchorCaptureGroupIndex, focusCaptureGroupIndex, scanningContext, parentElementNode) {
   const patternMatchResults = scanningContext.patternMatchResults;
   const regExCaptureGroups = patternMatchResults.regExCaptureGroups;
-  const newSelection = createSelectionWithCaptureGroups(anchorCaptureGroupIndex, focusCaptureGroupIndex, false, true, scanningContext);
+  const newSelection = createSelectionWithCaptureGroups(anchorCaptureGroupIndex, focusCaptureGroupIndex, false, true, scanningContext, parentElementNode);
 
   if (newSelection != null) {
     lexical.$setSelection(newSelection);
@@ -627,7 +769,7 @@ function removeTextByCaptureGroups(anchorCaptureGroupIndex, focusCaptureGroupInd
   }
 }
 
-function insertTextPriorToCaptureGroup(captureGroupIndex, text, scanningContext) {
+function insertTextPriorToCaptureGroup(captureGroupIndex, text, scanningContext, parentElementNode) {
   const patternMatchResults = scanningContext.patternMatchResults;
   const regExCaptureGroups = patternMatchResults.regExCaptureGroups;
   const regExCaptureGroupsCount = regExCaptureGroups.length;
@@ -641,7 +783,7 @@ function insertTextPriorToCaptureGroup(captureGroupIndex, text, scanningContext)
     offsetInParent: captureGroupDetail.offsetInParent,
     text
   };
-  const newSelection = createSelectionWithCaptureGroups(captureGroupIndex, captureGroupIndex, false, false, scanningContext);
+  const newSelection = createSelectionWithCaptureGroups(captureGroupIndex, captureGroupIndex, false, false, scanningContext, parentElementNode);
 
   if (newSelection != null) {
     lexical.$setSelection(newSelection);
@@ -662,7 +804,7 @@ function insertTextPriorToCaptureGroup(captureGroupIndex, text, scanningContext)
   }
 }
 
-function formatTextInCaptureGroupIndex(formatTypes, captureGroupIndex, scanningContext) {
+function formatTextInCaptureGroupIndex(formatTypes, captureGroupIndex, scanningContext, parentElementNode) {
   const patternMatchResults = scanningContext.patternMatchResults;
   const regExCaptureGroups = patternMatchResults.regExCaptureGroups;
   const regExCaptureGroupsCount = regExCaptureGroups.length;
@@ -677,7 +819,7 @@ function formatTextInCaptureGroupIndex(formatTypes, captureGroupIndex, scanningC
     return;
   }
 
-  const newSelection = createSelectionWithCaptureGroups(captureGroupIndex, captureGroupIndex, false, true, scanningContext);
+  const newSelection = createSelectionWithCaptureGroups(captureGroupIndex, captureGroupIndex, false, true, scanningContext, parentElementNode);
 
   if (newSelection != null) {
     lexical.$setSelection(newSelection);
@@ -692,7 +834,7 @@ function formatTextInCaptureGroupIndex(formatTypes, captureGroupIndex, scanningC
 } // Place caret at end of final capture group.
 
 
-function selectAfterFinalCaptureGroup(scanningContext) {
+function selectAfterFinalCaptureGroup(scanningContext, parentElementNode) {
   const patternMatchResults = scanningContext.patternMatchResults;
   const groupCount = patternMatchResults.regExCaptureGroups.length;
 
@@ -702,7 +844,7 @@ function selectAfterFinalCaptureGroup(scanningContext) {
   }
 
   const lastGroupIndex = groupCount - 1;
-  const newSelection = createSelectionWithCaptureGroups(lastGroupIndex, lastGroupIndex, true, true, scanningContext);
+  const newSelection = createSelectionWithCaptureGroups(lastGroupIndex, lastGroupIndex, true, true, scanningContext, parentElementNode);
 
   if (newSelection != null) {
     lexical.$setSelection(newSelection);
@@ -717,30 +859,6 @@ function selectAfterFinalCaptureGroup(scanningContext) {
  *
  * 
  */
-function getAllTriggers() {
-  return triggers;
-}
-function getAllMarkdownCriteriaForTextNodes() {
-  return allMarkdownCriteriaForTextNodes;
-}
-function getAllMarkdownCriteria() {
-  return allMarkdownCriteria;
-}
-function transformTextNodeForMarkdownCriteria(scanningContext, createHorizontalRuleNode) {
-  if (scanningContext.markdownCriteria.requiresParagraphStart === true) {
-    transformTextNodeForParagraphs(scanningContext, createHorizontalRuleNode);
-  } else {
-    transformTextNodeForText(scanningContext);
-  }
-}
-
-function getPatternMatchResultsForCriteria(markdownCriteria, scanningContext) {
-  if (markdownCriteria.requiresParagraphStart === true) {
-    return getPatternMatchResultsForParagraphs(markdownCriteria, scanningContext);
-  }
-
-  return getPatternMatchResultsForText(markdownCriteria, scanningContext);
-}
 
 function getTextNodeForAutoFormatting(selection) {
   if (!lexical.$isRangeSelection(selection)) {
@@ -761,7 +879,8 @@ function getTextNodeForAutoFormatting(selection) {
 
 function updateAutoFormatting(editor, scanningContext, createHorizontalRuleNode) {
   editor.update(() => {
-    transformTextNodeForMarkdownCriteria(scanningContext, createHorizontalRuleNode);
+    const elementNode = getTextNodeWithOffsetOrThrow(scanningContext).node.getParentOrThrow();
+    transformTextNodeForMarkdownCriteria(scanningContext, elementNode, createHorizontalRuleNode);
   }, {
     tag: 'history-push'
   });
@@ -775,7 +894,7 @@ function getCriteriaWithPatternMatchResults(markdownCriteriaArray, scanningConte
     const markdownCriteria = markdownCriteriaArray[i]; // Skip code block nodes, unless the autoFormatKind calls for toggling the code block.
 
     if (currentTriggerState != null && currentTriggerState.isCodeBlock === false || markdownCriteria.markdownFormatKind === 'paragraphCodeBlock') {
-      const patternMatchResults = getPatternMatchResultsForCriteria(markdownCriteria, scanningContext);
+      const patternMatchResults = getPatternMatchResultsForCriteria(markdownCriteria, scanningContext, getParentElementNodeOrThrow(scanningContext));
 
       if (patternMatchResults != null) {
         return {
@@ -859,7 +978,9 @@ function findScanningContext(editor, currentTriggerState, priorTriggerState) {
 
     const triggerStringLength = triggerString.length;
     const currentTextContentLength = currentTriggerState.textContent.length;
-    const triggerOffset = currentTriggerState.anchorOffset - triggerStringLength;
+    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) {
@@ -904,61 +1025,117 @@ function convertStringToLexical(text, editor) {
 
   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.
 
-function convertElementNodeContainingMarkdown(scanningContext, elementNode, createHorizontalRuleNode) {
+  while (!done) {
+    done = true;
+    const elementNodes = root.getChildren();
+    const countOfElementNodes = elementNodes.length;
+
+    for (let i = startIndex; i < countOfElementNodes; i++) {
+      const elementNode = elementNodes[i];
+
+      if (lexical.$isElementNode(elementNode)) {
+        convertParagraphLevelMarkdown(scanningContext, elementNode, createHorizontalRuleNode);
+      } // Reset the scanning information that relates to the particular element node.
+
+
+      resetScanningContext(scanningContext);
+
+      if (root.getChildren().length !== countOfElementNodes) {
+        // The conversion added or removed an from root's children.
+        startIndex = i;
+        done = false;
+        break;
+      }
+    }
+  } // while
+
+
+  done = false;
+  startIndex = 0; // Handle the text level markdown.
+
+  while (!done) {
+    done = true;
+    const elementNodes = root.getChildren();
+    const countOfElementNodes = elementNodes.length;
+
+    for (let i = startIndex; i < countOfElementNodes; i++) {
+      const elementNode = elementNodes[i];
+
+      if (lexical.$isElementNode(elementNode)) {
+        convertTextLevelMarkdown(scanningContext, elementNode, createHorizontalRuleNode);
+      } // Reset the scanning information that relates to the particular element node.
+
+
+      resetScanningContext(scanningContext);
+    }
+  } // while
+
+}
+
+function convertParagraphLevelMarkdown(scanningContext, elementNode, createHorizontalRuleNode) {
   const textContent = elementNode.getTextContent(); // Handle paragraph nodes below.
 
-  if (lexical.$isParagraphNode(elementNode) && elementNode.getChildren().length) {
+  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)) {
-        throw Error(`Expect paragraph containing only text nodes.`);
-      }
-
-      scanningContext.textNodeWithOffset = {
-        node: firstChild,
-        offset: 0
-      };
-      const patternMatchResults = getPatternMatchResultsForCodeBlock(scanningContext, textContent);
+      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;
+        if (patternMatchResults != null) {
+          // Toggle transform to or from code block.
+          scanningContext.patternMatchResults = patternMatchResults;
+        }
       }
 
       scanningContext.markdownCriteria = getCodeBlockCriteria(); // Perform text transformation here.
 
-      transformTextNodeForParagraphs(scanningContext, createHorizontalRuleNode);
+      transformTextNodeForMarkdownCriteria(scanningContext, elementNode, createHorizontalRuleNode);
       return;
     }
 
-    const allCriteria = getAllMarkdownCriteria();
-    const count = allCriteria.length;
+    if (elementNode.getChildren().length) {
+      const allCriteria = getAllMarkdownCriteriaForParagraphs();
+      const count = allCriteria.length;
+      scanningContext.joinedText = paragraphNode.getTextContent();
 
-    for (let i = 0; i < count; i++) {
-      const criteria = allCriteria[i];
+      if (!(firstChild != null && firstChildIsTextNode)) {
+        throw Error(`Expect paragraph containing only text nodes.`);
+      }
 
-      if (criteria.requiresParagraphStart === true) {
-        if (!(firstChild != null && firstChildIsTextNode)) {
-          throw Error(`Expect paragraph containing only text nodes.`);
+      scanningContext.textNodeWithOffset = {
+        node: firstChild,
+        offset: 0
+      };
+
+      for (let i = 0; i < count; i++) {
+        const criteria = allCriteria[i];
+
+        if (criteria.requiresParagraphStart === false) {
+          return;
         }
 
-        scanningContext.textNodeWithOffset = {
-          node: firstChild,
-          offset: 0
-        };
-        scanningContext.joinedText = paragraphNode.getTextContent();
-        const patternMatchResults = getPatternMatchResultsForParagraphs(criteria, scanningContext);
+        const patternMatchResults = getPatternMatchResultsForCriteria(criteria, scanningContext, getParentElementNodeOrThrow(scanningContext));
 
         if (patternMatchResults != null) {
-          // Lazy fill-in the particular format criteria and any matching result information.
           scanningContext.markdownCriteria = criteria;
           scanningContext.patternMatchResults = patternMatchResults; // Perform text transformation here.
 
-          transformTextNodeForParagraphs(scanningContext, createHorizontalRuleNode);
+          transformTextNodeForMarkdownCriteria(scanningContext, elementNode, createHorizontalRuleNode);
           return;
         }
       }
@@ -966,37 +1143,101 @@ function convertElementNodeContainingMarkdown(scanningContext, elementNode, crea
   }
 }
 
-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;
+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.
+
+
+  const children = elementNode.getChildren();
+  const countOfChildren = children.length;
+
+  for (let i = 0; i < countOfChildren; i++) {
+    const node = children[i];
+
+    if (lexical.$isElementNode(node)) {
+      // Recurse down until we find a text node.
+      convertTextLevelMarkdown(scanningContext, node, createHorizontalRuleNode);
+    }
+  }
+}
+
+function convertMarkdownForTextCriteria(scanningContext, elementNode, createHorizontalRuleNode) {
+  resetScanningContext(scanningContext); // Cycle through all the criteria and convert all text patterns in the parent element.
+
+  const allCriteria = getAllMarkdownCriteriaForTextNodes();
+  const count = allCriteria.length;
+  let textContent = elementNode.getTextContent();
+  let done = textContent.length === 0;
   let startIndex = 0;
 
   while (!done) {
     done = true;
-    const elementNodes = root.getChildren();
-    const countOfElementNodes = elementNodes.length;
 
-    for (let i = startIndex; i < countOfElementNodes; i++) {
-      const elementNode = elementNodes[i];
+    for (let i = startIndex; i < count; i++) {
+      const criteria = allCriteria[i];
 
-      if (lexical.$isElementNode(elementNode)) {
-        convertElementNodeContainingMarkdown(scanningContext, elementNode, createHorizontalRuleNode);
-      } // Reset the scanning information that relates to the particular element node.
+      if (scanningContext.textNodeWithOffset == null) {
+        // Need to search through the very last text node in the element.
+        const lastTextNode = getLastTextNodeInElementNode(elementNode);
 
+        if (lastTextNode == null) {
+          // If we have no more text nodes, then there's nothing to search and transform.
+          return;
+        }
 
-      resetScanningContext(scanningContext);
+        scanningContext.textNodeWithOffset = {
+          node: lastTextNode,
+          offset: lastTextNode.getTextContent().length
+        };
+      }
 
-      if (root.getChildren().length !== countOfElementNodes) {
-        // The conversion added or removed an from root's children.
+      const patternMatchResults = getPatternMatchResultsForCriteria(criteria, scanningContext, elementNode);
+
+      if (patternMatchResults != null) {
+        scanningContext.markdownCriteria = criteria;
+        scanningContext.patternMatchResults = patternMatchResults; // Perform text transformation here.
+
+        transformTextNodeForMarkdownCriteria(scanningContext, elementNode, createHorizontalRuleNode);
+        resetScanningContext(scanningContext);
+        const currentTextContent = elementNode.getTextContent();
+
+        if (currentTextContent.length === 0) {
+          // Nothing left to convert.
+          return;
+        }
+
+        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.
+
+
+        textContent = currentTextContent;
         startIndex = i;
         done = false;
         break;
       }
     }
-  } // while
+  }
+}
 
+function getLastTextNodeInElementNode(elementNode) {
+  const children = elementNode.getChildren();
+  const countOfChildren = children.length;
+
+  for (let i = countOfChildren - 1; i >= 0; i--) {
+    if (lexical.$isTextNode(children[i])) {
+      return children[i];
+    }
+  }
+
+  return null;
 }
 
 /**

package/LexicalMarkdown.prod.js

@@ -4,29 +4,37 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var k=require("@lexical/code"),p=require("@lexical/list"),q=require("lexical"),t=require("@lexical/link"),u=require("@lexical/rich-text"),v=require("@lexical/text");function w(b){throw Error(`Minified Lexical error #${b}; see codes.json for the full message or `+"use the non-minified dev environment for full errors and additional helpful warnings.");}
-const y=[{triggerKind:"space_trigger",triggerString:" "}],z={markdownFormatKind:null,regEx:/(?:)/,regExForAutoFormatting:/(?:)/,requiresParagraphStart:!1},A={...z,requiresParagraphStart:!0},B={...A,markdownFormatKind:"paragraphCodeBlock",regEx:/^(```)$/,regExForAutoFormatting:/^(```)([a-z]*)( )/},C=[{...z,markdownFormatKind:"bold_italic",regEx:/(\*\*\*)(\s*\b)([^\*\*\*]*)(\b\s*)(\*\*\*)/,regExForAutoFormatting:/(\*\*\*)(\s*\b)([^\*\*\*]*)(\b\s*)(\*\*\*)(\s)$/},{...z,markdownFormatKind:"italic",regEx:/(\*)(\s*\b)([^\*]*)(\b\s*)(\*)/,
-regExForAutoFormatting:/(\*)(\s*\b)([^\*]*)(\b\s*)(\*)(\s)$/},{...z,markdownFormatKind:"bold",regEx:/(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)/,regExForAutoFormatting:/(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)(\s)$/},{...z,markdownFormatKind:"bold",regEx:/(__)(\s*)([^__]*)(\s*)(__)/,regExForAutoFormatting:/(__)(\s*)([^__]*)(\s*)(__)(\s)$/},{...z,markdownFormatKind:"underline",regEx:/(<u>)(\s*\b)([^<]*)(\b\s*)(<\/u>)/,regExForAutoFormatting:/(<u>)(\s*\b)([^<]*)(\b\s*)(<\/u>)(\s)$/},{...z,markdownFormatKind:"strikethrough",
-regEx:/(~~)(\s*\b)([^~~]*)(\b\s*)(~~)/,regExForAutoFormatting:/(~~)(\s*\b)([^~~]*)(\b\s*)(~~)(\s)$/},{...z,markdownFormatKind:"link",regEx:/(\[)(.+)(\]\()([^ ]+)(?: "(?:.+)")?(\))/,regExForAutoFormatting:/(\[)(.+)(\]\()([^ ]+)(?: "(?:.+)")?(\))(\s)$/}],D=[{...A,markdownFormatKind:"paragraphH1",regEx:/^(?:#)/,regExForAutoFormatting:/^(?:# )/},{...A,markdownFormatKind:"paragraphH2",regEx:/^(?:##)/,regExForAutoFormatting:/^(?:## )/},{...A,markdownFormatKind:"paragraphH2",regEx:/^(?:###)/,regExForAutoFormatting:/^(?:### )/},
-{...A,markdownFormatKind:"paragraphBlockQuote",regEx:/^(?:>)/,regExForAutoFormatting:/^(?:> )/},{...A,markdownFormatKind:"paragraphUnorderedList",regEx:/^(?:- )/,regExForAutoFormatting:/^(?:- )/},{...A,markdownFormatKind:"paragraphUnorderedList",regEx:/^(?:\* )/,regExForAutoFormatting:/^(?:\* )/},{...A,markdownFormatKind:"paragraphOrderedList",regEx:/^(\d+)\.\s/,regExForAutoFormatting:/^(\d+)\.\s/},B,{...A,markdownFormatKind:"horizontalRule",regEx:/^(?:\*\*\*)$/,regExForAutoFormatting:/^(?:\*\*\* )/},
-{...A,markdownFormatKind:"horizontalRule",regEx:/^(?:---)$/,regExForAutoFormatting:/^(?:--- )/},...C];function E(b,e,d,c){return{currentElementNode:null,editor:b,isAutoFormatting:e,isWithinCodeBlock:!1,joinedText:null,markdownCriteria:{markdownFormatKind:"noTransformation",regEx:/(?:)/,regExForAutoFormatting:/(?:)/,requiresParagraphStart:null},patternMatchResults:{regExCaptureGroups:[]},textNodeWithOffset:d,triggerState:c}}
-function F(b,e,d,c){const a={regExCaptureGroups:[]};c=b.match(c);if(null!==c&&0<c.length&&(!1===e||0===c.index)&&(!1===d||c.index+c[0].length===b.length)){b=c.length;e=c.index;for(d=0;d<b;d++){const f=c[d];a.regExCaptureGroups.push({offsetInParent:e,text:f});0<d&&(e+=f.length)}return a}return null}function I(b){b=b.textNodeWithOffset;null==b&&w(82);return b}
-function J(b,e){var d=I(e);return null===d.node.getPreviousSibling()?(d=d.node.getTextContent(),F(d,!0,!1,e.isAutoFormatting?b.regExForAutoFormatting:b.regEx)):null}
-function K(b,e){var d=I(b);const c=d.node.getParentOrThrow();0<b.patternMatchResults.regExCaptureGroups.length&&(d=d.node.spliceText(0,b.patternMatchResults.regExCaptureGroups[0].text.length,"",!0),""===d.getTextContent()&&(d.selectPrevious(),d.remove()));a:{var a=null;d=c.getChildren();const g=b.markdownCriteria,l=b.patternMatchResults;if(null!=g.markdownFormatKind)switch(g.markdownFormatKind){case "paragraphH1":a=u.$createHeadingNode("h1");a.append(...d);break;case "paragraphH2":a=u.$createHeadingNode("h2");
-a.append(...d);break;case "paragraphH3":a=u.$createHeadingNode("h3");a.append(...d);break;case "paragraphBlockQuote":a=u.$createQuoteNode();a.append(...d);break;case "paragraphUnorderedList":a=p.$createListNode("ul");b=p.$createListItemNode();b.append(...d);a.append(b);break;case "paragraphOrderedList":a=parseInt(1<l.regExCaptureGroups.length?l.regExCaptureGroups[l.regExCaptureGroups.length-1].text:"1",10);a=p.$createListNode("ol",a);b=p.$createListItemNode();b.append(...d);a.append(b);break;case "paragraphCodeBlock":if(!1===
-b.isAutoFormatting){if(0<b.patternMatchResults.regExCaptureGroups.length){b.isWithinCodeBlock=!0!==b.isWithinCodeBlock;b.currentElementNode=null;d={newNode:null,shouldDelete:!0};break a}if(b.isWithinCodeBlock){if(null==b.currentElementNode){a=k.$createCodeNode();a.append(...d);b.currentElementNode=a;d={newNode:a,shouldDelete:!1};break a}null!=b.currentElementNode&&(a=b.currentElementNode,b=q.$createLineBreakNode(),a.append(b),a.append(...d))}d={newNode:null,shouldDelete:!0};break a}null!=b.triggerState&&
-b.triggerState.isCodeBlock?a=q.$createParagraphNode():(a=k.$createCodeNode(),b=3<=l.regExCaptureGroups.length?l.regExCaptureGroups[2].text:null,null!=b&&0<b.length&&a.setLanguage(b));a.append(...d);break;case "horizontalRule":null!=e&&(d=e(),c.insertBefore(d))}d={newNode:a,shouldDelete:!1}}const {newNode:f,shouldDelete:h}=d;h?c.remove():null!==f&&c.replace(f)}
-function L(b,e,d,c,a){var f=a.patternMatchResults;const h=f.regExCaptureGroups;var g=h.length;if(b>=g||e>=g)return null;a=I(a).node.getParentOrThrow();g=f.regExCaptureGroups.length;2>g?f=0:(--g,f=f.regExCaptureGroups[g].offsetInParent+f.regExCaptureGroups[g].text.length);b=h[b];e=h[e];c=c?e.offsetInParent+e.text.length:e.offsetInParent;d=v.$findNodeWithOffsetFromJoinedText(d?b.offsetInParent+b.text.length:b.offsetInParent,f,1,a);c=v.$findNodeWithOffsetFromJoinedText(c,f,1,a);if(null==d||null==c)return null;
-a=q.$createRangeSelection();a.anchor.set(d.node.getKey(),d.offset,"text");a.focus.set(c.node.getKey(),c.offset,"text");return a}function M(b,e,d){const c=d.patternMatchResults.regExCaptureGroups;d=L(b,e,!1,!0,d);if(null!=d&&(q.$setSelection(d),d=q.$getSelection(),null!=d&&q.$isRangeSelection(d)&&!1===d.isCollapsed())){d.removeText();d=0;const a=c.length;for(let f=b;f<a;f++){const h=c[f];f>b&&(h.offsetInParent-=d);f<=e&&(d+=h.text.length,h.text="")}}}
-function P(b){var e=b.patternMatchResults.regExCaptureGroups.length;2>e||(--e,b=L(e,e,!0,!0,b),null!=b&&q.$setSelection(b))}
-function Q(b,e,d){b.update(()=>{if(!0===e.markdownCriteria.requiresParagraphStart)K(e,d);else{var c=e.markdownCriteria;if(null!=c.markdownFormatKind){a:{var a=c.markdownFormatKind;switch(a){case "italic":case "bold":case "underline":case "strikethrough":a=[a];break a;case "bold_italic":a=["bold","italic"];break a}a=null}if(null!=a){if(c=a,7===e.patternMatchResults.regExCaptureGroups.length){M(5,5,e);M(1,1,e);a=e.patternMatchResults.regExCaptureGroups;3<a.length||w(65);if(0!==a[3].text.length&&(a=
-L(3,3,!1,!0,e),null!=a&&(q.$setSelection(a),a=q.$getSelection(),q.$isRangeSelection(a))))for(var f=0;f<c.length;f++)a.formatText(c[f]);P(e)}}else if("link"===c.markdownFormatKind&&(c=e.patternMatchResults.regExCaptureGroups,7===c.length&&(f=c[2].text,c=c[4].text,0!==f.length&&0!==c.length))){M(1,5,e);a=e.patternMatchResults.regExCaptureGroups;if(!(1>=a.length)){f={offsetInParent:a[1].offsetInParent,text:f};var h=L(1,1,!1,!1,e);if(null!=h&&(q.$setSelection(h),h=q.$getSelection(),null!=h&&q.$isRangeSelection(h)&&
-h.isCollapsed())){h.insertText(f.text);a.splice(1,0,f);f=f.text.length;h=a.length;for(let g=2;g<h;g++)a[g].offsetInParent+=f}}a=L(1,1,!1,!0,e);null!=a&&(q.$setSelection(a),e.editor.dispatchCommand(t.TOGGLE_LINK_COMMAND,c),P(e))}}}},{tag:"history-push"})}
-function R(b,e){let d=null;b.getEditorState().read(()=>{var c=q.$getSelection();if(q.$isRangeSelection(c)){var a=c.anchor.getNode();c=q.$isTextNode(a)?{node:a,offset:c.anchor.offset}:null}else c=null;if(null!==c){c=E(b,!0,c,e);a:{a=!1===e.isParentAListItemNode?D:C;const g=c.triggerState,l=a.length;for(let n=0;n<l;n++){const r=a[n];if(null!=g&&!1===g.isCodeBlock||"paragraphCodeBlock"===r.markdownFormatKind){var f=r,h=c;if(!0===f.requiresParagraphStart)f=J(f,h);else{if(null==h.joinedText){const m=I(h).node.getParentOrThrow();
-q.$isElementNode(m)?null==h.joinedText&&(h.joinedText=v.$joinTextNodesInElementNode(m,"\u0004",I(h))):w(52,m.__key)}f=F(h.joinedText,!1,!0,f.regExForAutoFormatting)}if(null!=f){a={markdownCriteria:r,patternMatchResults:f};break a}}}a={markdownCriteria:null,patternMatchResults:null}}null!==a.markdownCriteria&&null!==a.patternMatchResults&&(d=c,d.markdownCriteria=a.markdownCriteria,d.patternMatchResults=a.patternMatchResults)}});return d}
-function S(b){let e=null;b.read(()=>{const d=q.$getSelection();if(q.$isRangeSelection(d)&&d.isCollapsed()){var c=d.anchor.getNode(),a=c.getParent(),f=p.$isListItemNode(a);e={anchorOffset:d.anchor.offset,hasParentNode:null!==a,isCodeBlock:k.$isCodeNode(c),isParentAListItemNode:f,isSelectionCollapsed:!0,isSimpleText:q.$isTextNode(c)&&c.isSimpleText(),nodeKey:c.getKey(),textContent:c.getTextContent()}}});return e}
-exports.$convertFromMarkdownString=function(b,e,d){if(b.length){var c=[];b=b.split("\n");var a=b.length;for(var f=0;f<a;f++)0<b[f].length?c.push(q.$createParagraphNode().append(q.$createTextNode(b[f]))):c.push(q.$createParagraphNode());c.length?(b=q.$getRoot(),b.clear(),b.append(...c),c=b):c=null}else c=null;if(null!=c)for(e=E(e,!1,null,null),c=q.$getRoot(),b=!1,a=0;!b;){b=!0;f=c.getChildren();const r=f.length;for(let m=a;m<r;m++){var h=f[m];if(q.$isElementNode(h)){var g=e,l=h;h=d;var n=l.getTextContent();
-if(q.$isParagraphNode(l)&&l.getChildren().length){const x=l.getFirstChild(),N=q.$isTextNode(x);if(!0===g.isWithinCodeBlock)null!=x&&N||w(80),g.textNodeWithOffset={node:x,offset:0},l=F(n,!0,!1,g.isAutoFormatting?B.regExForAutoFormatting:B.regEx),null!=l&&(g.patternMatchResults=l),g.markdownCriteria=B,K(g,h);else{n=D.length;for(let G=0;G<n;G++){const H=D[G];if(!0===H.requiresParagraphStart){null!=x&&N||w(80);g.textNodeWithOffset={node:x,offset:0};g.joinedText=l.getTextContent();const O=J(H,g);if(null!=
-O){g.markdownCriteria=H;g.patternMatchResults=O;K(g,h);break}}}}}}g=e;g.joinedText="";g.markdownCriteria={markdownFormatKind:"noTransformation",regEx:/(?:)/,regExForAutoFormatting:/(?:)/,requiresParagraphStart:null};g.patternMatchResults={regExCaptureGroups:[]};g.triggerState=null;g.textNodeWithOffset=null;if(c.getChildren().length!==r){a=m;b=!1;break}}}};
-exports.registerMarkdownShortcuts=function(b,e){let d=null;return b.registerUpdateListener(({tags:c})=>{if(!1===c.has("historic")){c=S(b.getEditorState());if(null==c)var a=null;else a:{a=c;var f=d;if(null==a||null==f)a=null;else{var h=y.length;for(let g=0;g<h;g++){const l=y[g].triggerString,n=l.length,r=a.textContent.length,m=a.anchorOffset-n;if(!1===(!0===a.hasParentNode&&a.isSimpleText&&a.isSelectionCollapsed&&a.anchorOffset!==f.anchorOffset&&0<=m&&m+n<=r&&a.textContent.substr(m,n)===l&&a.textContent!==
-f.textContent)){a=null;break a}}a=R(b,a)}}null!=a&&Q(b,a,e);d=c}else d=null})};
+var k=require("@lexical/code"),n=require("@lexical/list"),p=require("lexical"),u=require("@lexical/link"),v=require("@lexical/rich-text"),x=require("@lexical/text");function y(a){throw Error(`Minified Lexical error #${a}; see codes.json for the full message or `+"use the non-minified dev environment for full errors and additional helpful warnings.");}
+const z=[{triggerKind:"space_trigger",triggerString:" "}],A={markdownFormatKind:null,regEx:/(?:)/,regExForAutoFormatting:/(?:)/,requiresParagraphStart:!1},B={...A,requiresParagraphStart:!0},C={...B,markdownFormatKind:"paragraphCodeBlock",regEx:/^(```)$/,regExForAutoFormatting:/^(```)([a-z]*)( )/},D=[{...A,markdownFormatKind:"strikethrough_italic_bold",regEx:/(~~_\*\*)(\s*\b)([^~~_\*\*][^\*\*_~~]*)(\b\s*)(\*\*_~~)()/,regExForAutoFormatting:/(~~_\*\*)(\s*\b)([^~~_\*\*][^\*\*_~~]*)(\b\s*)(\*\*_~~)(\s)$/},
+{...A,markdownFormatKind:"italic_bold",regEx:/(_\*\*)(\s*\b)([^_\*\*][^\*\*_]*)(\b\s*)(\*\*_)/,regExForAutoFormatting:/(_\*\*)(\s*\b)([^_\*\*][^\*\*_]*)(\b\s*)(\*\*_)(\s)$/},{...A,markdownFormatKind:"strikethrough_italic",regEx:/(~~_)(\s*)([^~~_][^_~~]*)(\s*)(_~~)/,regExForAutoFormatting:/(~~_)(\s*)([^~~_][^_~~]*)(\s*)(_~~)(\s)$/},{...A,markdownFormatKind:"strikethrough_bold",regEx:/(~~\*\*)(\s*\b)([^~~\*\*][^\*\*~~]*)(\b\s*)(\*\*~~)/,regExForAutoFormatting:/(~~\*\*)(\s*\b)([^~~\*\*][^\*\*~~]*)(\b\s*)(\*\*~~)(\s)$/},
+{...A,markdownFormatKind:"code",regEx:/(`)([^`]*)(`)/,regExForAutoFormatting:/(`)(\s*\b)([^`]*)(\b\s*)(`)(\s)$/},{...A,markdownFormatKind:"bold",regEx:/(\*\*)(\s*)([^\*\*]*)(\s*)(\*\*)()/,regExForAutoFormatting:/(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)(\s)$/},{...A,markdownFormatKind:"italic",regEx:/(\*)(\s*)([^\*]*)(\s*)(\*)()/,regExForAutoFormatting:/(\*)(\s*\b)([^\*]*)(\b\s*)(\*)(\s)$/},{...A,markdownFormatKind:"bold",regEx:/(__)(\s*)([^__]*)(\s*)(__)()/,regExForAutoFormatting:/(__)(\s*)([^__]*)(\s*)(__)(\s)$/},
+{...A,markdownFormatKind:"italic",regEx:/(_)()([^_]*)()(_)()/,regExForAutoFormatting:/(_)()([^_]*)()(_)(\s)$/},{...A,markdownFormatKind:"underline",regEx:/(<u>)(\s*)([^<]*)(\s*)(<\/u>)()/,regExForAutoFormatting:/(<u>)(\s*\b)([^<]*)(\b\s*)(<\/u>)(\s)$/},{...A,markdownFormatKind:"strikethrough",regEx:/(~~)(\s*)([^~~]*)(\s*)(~~)()/,regExForAutoFormatting:/(~~)(\s*\b)([^~~]*)(\b\s*)(~~)(\s)$/},{...A,markdownFormatKind:"link",regEx:/(\[)([^\]]*)(\]\()([^)]*)(\)*)()/,regExForAutoFormatting:/(\[)([^\]]*)(\]\()([^)]*)(\)*)(\s)$/}],
+E=[{...B,markdownFormatKind:"paragraphH1",regEx:/^(?:# )/,regExForAutoFormatting:/^(?:# )/},{...B,markdownFormatKind:"paragraphH2",regEx:/^(?:## )/,regExForAutoFormatting:/^(?:## )/},{...B,markdownFormatKind:"paragraphH3",regEx:/^(?:### )/,regExForAutoFormatting:/^(?:### )/},{...B,markdownFormatKind:"paragraphH4",regEx:/^(?:#### )/,regExForAutoFormatting:/^(?:#### )/},{...B,markdownFormatKind:"paragraphH5",regEx:/^(?:##### )/,regExForAutoFormatting:/^(?:##### )/},{...B,markdownFormatKind:"paragraphBlockQuote",
+regEx:/^(?:> )/,regExForAutoFormatting:/^(?:> )/},{...B,markdownFormatKind:"paragraphUnorderedList",regEx:/^(\s{0,10})(?:- )/,regExForAutoFormatting:/^(\s{0,10})(?:- )/},{...B,markdownFormatKind:"paragraphUnorderedList",regEx:/^(\s{0,10})(?:\* )/,regExForAutoFormatting:/^(\s{0,10})(?:\* )/},{...B,markdownFormatKind:"paragraphOrderedList",regEx:/^(\s{0,10})(\d+)\.\s/,regExForAutoFormatting:/^(\s{0,10})(\d+)\.\s/},C,{...B,markdownFormatKind:"horizontalRule",regEx:/^(?:\*\*\*)$/,regExForAutoFormatting:/^(?:\*\*\* )/},
+{...B,markdownFormatKind:"horizontalRule",regEx:/^(?:---)$/,regExForAutoFormatting:/^(?:--- )/}],F=[...E,...D];function G(a,d,c,b){return{currentElementNode:null,editor:a,isAutoFormatting:d,isWithinCodeBlock:!1,joinedText:null,markdownCriteria:{markdownFormatKind:"noTransformation",regEx:/(?:)/,regExForAutoFormatting:/(?:)/,requiresParagraphStart:null},patternMatchResults:{regExCaptureGroups:[]},textNodeWithOffset:c,triggerState:b}}
+function H(a){a.joinedText=null;a.markdownCriteria={markdownFormatKind:"noTransformation",regEx:/(?:)/,regExForAutoFormatting:/(?:)/,requiresParagraphStart:null};a.patternMatchResults={regExCaptureGroups:[]};a.triggerState=null;a.textNodeWithOffset=null;return a}
+function I(a,d,c){if(!0===a.requiresParagraphStart)return c=J(d),null===c.node.getPreviousSibling()?(c=c.node.getTextContent(),a=K(c,!0,!1,d.isAutoFormatting?a.regExForAutoFormatting:a.regEx)):a=null,a;null==d.joinedText&&(p.$isElementNode(c)?null==d.joinedText&&(d.joinedText=x.$joinTextNodesInElementNode(c,"\u0004",J(d))):y(52,c.__key));return K(d.joinedText,!1,!0===a.regExForAutoFormatting,d.isAutoFormatting?a.regExForAutoFormatting:a.regEx)}
+function K(a,d,c,b){const e={regExCaptureGroups:[]};b=a.match(b);if(null!==b&&0<b.length&&(!1===d||0===b.index)&&(!1===c||b.index+b[0].length===a.length)){a=b.length;d=b.index;for(c=0;c<a;c++){const f=b[c];e.regExCaptureGroups.push({offsetInParent:d,text:f});0<c&&(d+=f.length)}return e}return null}function J(a){a=a.textNodeWithOffset;null==a&&y(82);return a}
+function L(a,d,c){var b=null,e=d.getChildren();const f=a.markdownCriteria,g=a.patternMatchResults;if(null!=f.markdownFormatKind)switch(f.markdownFormatKind){case "paragraphH1":b=v.$createHeadingNode("h1");b.append(...e);break;case "paragraphH2":b=v.$createHeadingNode("h2");b.append(...e);break;case "paragraphH3":b=v.$createHeadingNode("h3");b.append(...e);break;case "paragraphH4":b=v.$createHeadingNode("h4");b.append(...e);break;case "paragraphH5":b=v.$createHeadingNode("h5");b.append(...e);break;
+case "paragraphBlockQuote":b=v.$createQuoteNode();b.append(...e);break;case "paragraphUnorderedList":return M(d,e,g,"ul"),{newNode:null,shouldDelete:!1};case "paragraphOrderedList":return b=1<g.regExCaptureGroups.length?g.regExCaptureGroups[g.regExCaptureGroups.length-1].text:"1",a=a.isAutoFormatting?parseInt(b,10):void 0,M(d,e,g,"ol",a),{newNode:null,shouldDelete:!1};case "paragraphCodeBlock":if(!1===a.isAutoFormatting){if(0<a.patternMatchResults.regExCaptureGroups.length)return a.isWithinCodeBlock=
+!0!==a.isWithinCodeBlock,a.currentElementNode=null,{newNode:null,shouldDelete:!0};if(a.isWithinCodeBlock){if(null==a.currentElementNode)return d=k.$createCodeNode(),d.append(...e),a.currentElementNode=d,{newNode:d,shouldDelete:!1};null!=a.currentElementNode&&(d=a.currentElementNode,a=p.$createLineBreakNode(),d.append(a),e.length&&d.append(a),d.append(...e))}return{newNode:null,shouldDelete:!0}}null!=a.triggerState&&a.triggerState.isCodeBlock?b=p.$createParagraphNode():(b=k.$createCodeNode(),d=3<=
+g.regExCaptureGroups.length?g.regExCaptureGroups[2].text:null,null!=d&&0<d.length&&b.setLanguage(d));b.append(...e);break;case "horizontalRule":null!=c&&(e=c(),d.insertBefore(e))}return{newNode:b,shouldDelete:!1}}
+function M(a,d,c,b,e){const f=n.$createListItemNode();c=(c=c.regExCaptureGroups[0].text.match(/^\s*/))?Math.floor(c[0].length/4):0;f.append(...d);d=a.getPreviousSibling();n.$isListNode(d)&&d.getTag()===b?(d.append(f),a.remove()):(b=n.$createListNode(b,e),b.append(f),a.replace(b));c&&f.setIndent(c)}
+function N(a,d,c){if(!0===a.markdownCriteria.requiresParagraphStart){if(null!=a.textNodeWithOffset){var b=J(a);0<a.patternMatchResults.regExCaptureGroups.length&&(b=b.node.spliceText(0,a.patternMatchResults.regExCaptureGroups[0].text.length,"",!0),""===b.getTextContent()&&(b.selectPrevious(),b.remove()))}const {newNode:g,shouldDelete:h}=L(a,d,c);h?d.remove():null!==g&&d.replace(g)}else if(c=a.markdownCriteria,null!=c.markdownFormatKind)if(b=O(c.markdownFormatKind),null!=b){if(c=b,7===a.patternMatchResults.regExCaptureGroups.length){Q(5,
+5,a,d);Q(1,1,a,d);b=a.patternMatchResults.regExCaptureGroups;3<b.length||y(65);if(0!==b[3].text.length&&(b=R(3,3,!1,!0,a,d),null!=b&&(p.$setSelection(b),b=p.$getSelection(),p.$isRangeSelection(b))))for(var e=0;e<c.length;e++)b.formatText(c[e]);S(a,d)}}else if("link"===c.markdownFormatKind&&(c=a.patternMatchResults.regExCaptureGroups,7===c.length&&(e=c[2].text,c=c[4].text,0!==e.length&&0!==c.length))){Q(1,5,a,d);b=a.patternMatchResults.regExCaptureGroups;if(!(1>=b.length)){e={offsetInParent:b[1].offsetInParent,
+text:e};var f=R(1,1,!1,!1,a,d);if(null!=f&&(p.$setSelection(f),f=p.$getSelection(),null!=f&&p.$isRangeSelection(f)&&f.isCollapsed())){f.insertText(e.text);b.splice(1,0,e);e=e.text.length;f=b.length;for(let g=2;g<f;g++)b[g].offsetInParent+=e}}b=R(1,1,!1,!0,a,d);null!=b&&(p.$setSelection(b),a.editor.dispatchCommand(u.TOGGLE_LINK_COMMAND,c),S(a,d))}}
+function O(a){switch(a){case "italic":case "bold":case "underline":case "strikethrough":case "code":return[a];case "strikethrough_italic_bold":return["strikethrough","italic","bold"];case "italic_bold":return["italic","bold"];case "strikethrough_italic":return["strikethrough","italic"];case "strikethrough_bold":return["strikethrough","bold"]}return null}
+function R(a,d,c,b,e,f){var g=e.patternMatchResults;e=g.regExCaptureGroups;var h=e.length;if(a>=h||d>=h)return null;h=g.regExCaptureGroups.length;2>h?g=0:(--h,g=g.regExCaptureGroups[h].offsetInParent+g.regExCaptureGroups[h].text.length);a=e[a];d=e[d];b=b?d.offsetInParent+d.text.length:d.offsetInParent;c=x.$findNodeWithOffsetFromJoinedText(c?a.offsetInParent+a.text.length:a.offsetInParent,g,1,f);b=x.$findNodeWithOffsetFromJoinedText(b,g,1,f);if(null==c&&null==b&&0===f.getChildren().length)return c=
+p.$createRangeSelection(),c.anchor.set(f.getKey(),0,"element"),c.focus.set(f.getKey(),0,"element"),c;if(null==c||null==b)return null;f=p.$createRangeSelection();f.anchor.set(c.node.getKey(),c.offset,"text");f.focus.set(b.node.getKey(),b.offset,"text");return f}
+function Q(a,d,c,b){const e=c.patternMatchResults.regExCaptureGroups;c=R(a,d,!1,!0,c,b);if(null!=c&&(p.$setSelection(c),c=p.$getSelection(),null!=c&&p.$isRangeSelection(c)&&!1===c.isCollapsed())){c.removeText();c=0;b=e.length;for(let f=a;f<b;f++){const g=e[f];f>a&&(g.offsetInParent-=c);f<=d&&(c+=g.text.length,g.text="")}}}function S(a,d){var c=a.patternMatchResults.regExCaptureGroups.length;2>c||(--c,a=R(c,c,!0,!0,a,d),null!=a&&p.$setSelection(a))}
+function T(a,d,c){a.update(()=>{const b=J(d).node.getParentOrThrow();N(d,b,c)},{tag:"history-push"})}
+function U(a,d){let c=null;a.getEditorState().read(()=>{var b=p.$getSelection();if(p.$isRangeSelection(b)){var e=b.anchor.getNode();b=p.$isTextNode(e)?{node:e,offset:b.anchor.offset}:null}else b=null;if(null!==b){b=G(a,!0,b,d);a:{e=!1===d.isParentAListItemNode?F:D;const f=b.triggerState,g=e.length;for(let h=0;h<g;h++){const l=e[h];if(null!=f&&!1===f.isCodeBlock||"paragraphCodeBlock"===l.markdownFormatKind){const m=I(l,b,J(b).node.getParentOrThrow());if(null!=m){e={markdownCriteria:l,patternMatchResults:m};
+break a}}}e={markdownCriteria:null,patternMatchResults:null}}null!==e.markdownCriteria&&null!==e.patternMatchResults&&(c=b,c.markdownCriteria=e.markdownCriteria,c.patternMatchResults=e.patternMatchResults)}});return c}
+function V(a){let d=null;a.read(()=>{const c=p.$getSelection();if(p.$isRangeSelection(c)&&c.isCollapsed()){var b=c.anchor.getNode(),e=b.getParent(),f=n.$isListItemNode(e);d={anchorOffset:c.anchor.offset,hasParentNode:null!==e,isCodeBlock:k.$isCodeNode(b),isParentAListItemNode:f,isSelectionCollapsed:!0,isSimpleText:p.$isTextNode(b)&&b.isSimpleText(),nodeKey:b.getKey(),textContent:b.getTextContent()}}});return d}
+function W(a,d,c){var b=d.getFirstChild();if(p.$isTextNode(b))a:{H(a);b=D.length;var e=d.getTextContent(),f=0===e.length;let m=0;for(;!f;){f=!0;for(let t=m;t<b;t++){var g=D[t];if(null==a.textNodeWithOffset){b:{var h=d.getChildren();var l=h.length;for(--l;0<=l;l--)if(p.$isTextNode(h[l])){h=h[l];break b}h=null}if(null==h)break a;a.textNodeWithOffset={node:h,offset:h.getTextContent().length}}h=I(g,a,d);if(null!=h){a.markdownCriteria=g;a.patternMatchResults=h;N(a,d,c);H(a);g=d.getTextContent();if(0===
+g.length)break a;if(g!==e){e=g;m=t;f=!1;break}}}}}else for(d=d.getChildren(),b=d.length,e=0;e<b;e++)f=d[e],p.$isElementNode(f)&&W(a,f,c)}
+exports.$convertFromMarkdownString=function(a,d,c){if(a.length){var b=[];a=a.split("\n");var e=a.length;for(var f=0;f<e;f++)0<a[f].length?b.push(p.$createParagraphNode().append(p.$createTextNode(a[f]))):b.push(p.$createParagraphNode());b.length?(a=p.$getRoot(),a.clear(),a.append(...b),b=a):b=null}else b=null;if(null!=b){d=G(d,!1,null,null);b=p.$getRoot();a=!1;for(e=0;!a;){a=!0;var g=b.getChildren(),h=g.length;for(var l=e;l<h;l++){var m=g[l];if(p.$isElementNode(m)){f=d;var t=c;var r=m.getTextContent();
+if(p.$isParagraphNode(m)){var q=m.getFirstChild(),w=p.$isTextNode(q);if(!0===f.isWithinCodeBlock)null!=q&&w&&(f.textNodeWithOffset={node:q,offset:0},q=C,r=K(r,!0,!1,f.isAutoFormatting?q.regExForAutoFormatting:q.regEx),null!=r&&(f.patternMatchResults=r)),f.markdownCriteria=C,N(f,m,t);else if(m.getChildren().length)for(r=E.length,f.joinedText=m.getTextContent(),null!=q&&w||y(80),f.textNodeWithOffset={node:q,offset:0},q=0;q<r;q++){w=E[q];if(!1===w.requiresParagraphStart)break;const P=I(w,f,J(f).node.getParentOrThrow());
+if(null!=P){f.markdownCriteria=w;f.patternMatchResults=P;N(f,m,t);break}}}}H(d);if(b.getChildren().length!==h){e=l;a=!1;break}}}a=!1;for(e=0;!a;)for(a=!0,f=b.getChildren(),g=f.length,h=e;h<g;h++)l=f[h],p.$isElementNode(l)&&W(d,l,c),H(d)}};
+exports.registerMarkdownShortcuts=function(a,d){let c=null;return a.registerUpdateListener(({tags:b})=>{if(!1===b.has("historic")){b=V(a.getEditorState());if(null==b)var e=null;else a:{e=b;var f=c;if(null==e||null==f)e=null;else{var g=z.length;for(let h=0;h<g;h++){const l=z[h].triggerString,m=l.length,t=e.textContent.length,r=e.anchorOffset-m;if(!1===(!0===e.hasParentNode&&e.isSimpleText&&e.isSelectionCollapsed&&e.anchorOffset!==f.anchorOffset&&0<=r&&r+m<=t&&e.textContent.substr(r,m)===l&&e.textContent!==
+f.textContent)){e=null;break a}}e=U(a,e)}}null!=e&&T(a,e,d);c=b}else c=null})};

package/package.json

@@ -8,18 +8,18 @@
     "markdown"
   ],
   "license": "MIT",
-  "version": "0.1.21",
+  "version": "0.2.2",
   "main": "LexicalMarkdown.js",
   "peerDependencies": {
-    "lexical": "0.1.21"
+    "lexical": "0.2.2"
   },
   "dependencies": {
-    "@lexical/utils": "0.1.21",
-    "@lexical/code": "0.1.21",
-    "@lexical/text": "0.1.21",
-    "@lexical/rich-text": "0.1.21",
-    "@lexical/list": "0.1.21",
-    "@lexical/link": "0.1.21"
+    "@lexical/utils": "0.2.2",
+    "@lexical/code": "0.2.2",
+    "@lexical/text": "0.2.2",
+    "@lexical/rich-text": "0.2.2",
+    "@lexical/list": "0.2.2",
+    "@lexical/link": "0.2.2"
   },
   "repository": {
     "type": "git",