@lexical/markdown 0.2.0 → 0.2.3

package/LexicalMarkdown.dev.js

@@ -71,10 +71,20 @@ const markdownHeader2 = { ...paragraphStartBase,
   regExForAutoFormatting: /^(?:## )/
 };
 const markdownHeader3 = { ...paragraphStartBase,
-  markdownFormatKind: 'paragraphH2',
+  markdownFormatKind: 'paragraphH3',
   regEx: /^(?:### )/,
   regExForAutoFormatting: /^(?:### )/
 };
+const markdownHeader4 = { ...paragraphStartBase,
+  markdownFormatKind: 'paragraphH4',
+  regEx: /^(?:#### )/,
+  regExForAutoFormatting: /^(?:#### )/
+};
+const markdownHeader5 = { ...paragraphStartBase,
+  markdownFormatKind: 'paragraphH5',
+  regEx: /^(?:##### )/,
+  regExForAutoFormatting: /^(?:##### )/
+};
 const markdownBlockQuote = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphBlockQuote',
   regEx: /^(?:> )/,
@@ -115,24 +125,24 @@ const markdownInlineCode = { ...autoFormatBase,
   regEx: /(`)([^`]*)(`)/,
   regExForAutoFormatting: /(`)(\s*\b)([^`]*)(\b\s*)(`)(\s)$/
 };
-const markdownItalic = { ...autoFormatBase,
-  markdownFormatKind: 'italic',
-  regEx: /(\*)([^\*]*)(\*)/,
-  regExForAutoFormatting: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*)(\s)$/
-};
 const markdownBold = { ...autoFormatBase,
   markdownFormatKind: 'bold',
-  regEx: /(\*\*)([^\*\*]*)(\*\*)/,
+  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*)(__)/,
+  regEx: /(__)(\s*)([^__]*)(\s*)(__)()/,
   regExForAutoFormatting: /(__)(\s*)([^__]*)(\s*)(__)(\s)$/
 };
 const markdownItalic2 = { ...autoFormatBase,
   markdownFormatKind: 'italic',
-  regEx: /(_)([^_]*)(_)/,
+  regEx: /(_)()([^_]*)()(_)()/,
   regExForAutoFormatting: /(_)()([^_]*)()(_)(\s)$/ // Maintain 7 groups.
 
 }; // Markdown does not support underline, but we can allow folks to use
@@ -140,17 +150,17 @@ const markdownItalic2 = { ...autoFormatBase,
 
 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: /(~~)([^~~]*)(~~)/,
+  regEx: /(~~)(\s*)([^~~]*)(\s*)(~~)()/,
   regExForAutoFormatting: /(~~)(\s*\b)([^~~]*)(\b\s*)(~~)(\s)$/
 };
 const markdownStrikethroughItalicBold = { ...autoFormatBase,
   markdownFormatKind: 'strikethrough_italic_bold',
-  regEx: /(~~_\*\*)(\s*\b)([^~~_\*\*][^\*\*_~~]*)(\b\s*)(\*\*_~~)/,
+  regEx: /(~~_\*\*)(\s*\b)([^~~_\*\*][^\*\*_~~]*)(\b\s*)(\*\*_~~)()/,
   regExForAutoFormatting: /(~~_\*\*)(\s*\b)([^~~_\*\*][^\*\*_~~]*)(\b\s*)(\*\*_~~)(\s)$/
 };
 const markdownItalicbold = { ...autoFormatBase,
@@ -170,15 +180,29 @@ const markdownStrikethroughBold = { ...autoFormatBase,
 };
 const markdownLink = { ...autoFormatBase,
   markdownFormatKind: 'link',
-  regEx: /(\[)(.+)(\]\()([^ ]+)(?: \"(?:.+)\")?(\))/,
-  regExForAutoFormatting: /(\[)(.+)(\]\()([^ ]+)(?: \"(?:.+)\")?(\))(\s)$/
+  regEx: /(\[)([^\]]*)(\]\()([^)]*)(\)*)()/,
+  regExForAutoFormatting: /(\[)([^\]]*)(\]\()([^)]*)(\)*)(\s)$/
 };
 const allMarkdownCriteriaForTextNodes = [// Place the combination formats ahead of the individual formats.
 // Combos
 markdownStrikethroughItalicBold, markdownItalicbold, markdownStrikethroughItalic, markdownStrikethroughBold, // Individuals
-markdownInlineCode, markdownItalic, markdownBold, markdownBold2, markdownItalic2, // Must appear after markdownBold2.
+markdownInlineCode, markdownBold, markdownItalic, // Must appear after markdownBold
+markdownBold2, markdownItalic2, // Must appear after markdownBold2.
 fakeMarkdownUnderline, markdownStrikethrough, markdownLink];
-const allMarkdownCriteria = [markdownHeader1, markdownHeader2, markdownHeader3, markdownBlockQuote, markdownUnorderedListDash, markdownUnorderedListAsterisk, markdownOrderedList, markdownCodeBlock, markdownHorizontalRule, markdownHorizontalRuleUsingDashes, ...allMarkdownCriteriaForTextNodes];
+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,
@@ -202,7 +226,7 @@ function getInitialScanningContext(editor, isAutoFormatting, textNodeWithOffset,
   };
 }
 function resetScanningContext(scanningContext) {
-  scanningContext.joinedText = '';
+  scanningContext.joinedText = null;
   scanningContext.markdownCriteria = {
     markdownFormatKind: 'noTransformation',
     regEx: /(?:)/,
@@ -221,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);
@@ -270,6 +301,7 @@ function getTextNodeWithOffsetOrThrow(scanningContext) {
 
   return textNodeWithOffset;
 }
+
 function getPatternMatchResultsForParagraphs(markdownCriteria, scanningContext) {
   const textNodeWithOffset = getTextNodeWithOffsetOrThrow(scanningContext); // At start of paragraph.
 
@@ -280,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) {
@@ -338,6 +370,26 @@ function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNod
           };
         }
 
+      case 'paragraphH4':
+        {
+          newNode = richText.$createHeadingNode('h4');
+          newNode.append(...children);
+          return {
+            newNode,
+            shouldDelete
+          };
+        }
+
+      case 'paragraphH5':
+        {
+          newNode = richText.$createHeadingNode('h5');
+          newNode.append(...children);
+          return {
+            newNode,
+            shouldDelete
+          };
+        }
+
       case 'paragraphBlockQuote':
         {
           newNode = richText.$createQuoteNode();
@@ -479,6 +531,14 @@ function createListOrMergeWithPrevious(element, children, patternMatchResults, t
   }
 }
 
+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);
@@ -507,24 +567,25 @@ function transformTextNodeForElementNode(elementNode, scanningContext, createHor
     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;
 
@@ -543,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;
@@ -578,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;
@@ -590,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();
 }
 
@@ -643,7 +704,7 @@ function getTextFormatType(markdownFormatKind) {
   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;
@@ -652,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];
@@ -661,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;
   }
@@ -671,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);
@@ -702,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;
@@ -716,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);
@@ -737,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;
@@ -752,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);
@@ -767,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;
 
@@ -777,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);
@@ -792,31 +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) {
-    const elementNode = getTextNodeWithOffsetOrThrow(scanningContext).node.getParentOrThrow();
-    transformTextNodeForElementNode(elementNode, 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)) {
@@ -837,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'
   });
@@ -851,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 {
@@ -935,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) {
@@ -980,8 +1025,61 @@ 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.
+
+  while (!done) {
+    done = true;
+    const elementNodes = root.getChildren();
+    const countOfElementNodes = elementNodes.length;
+
+    for (let i = startIndex; i < countOfElementNodes; i++) {
+      const elementNode = elementNodes[i];
 
-function convertElementNodeContainingMarkdown(scanningContext, elementNode, createHorizontalRuleNode) {
+      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)) {
@@ -1006,74 +1104,140 @@ function convertElementNodeContainingMarkdown(scanningContext, elementNode, crea
 
       scanningContext.markdownCriteria = getCodeBlockCriteria(); // Perform text transformation here.
 
-      transformTextNodeForElementNode(elementNode, scanningContext, createHorizontalRuleNode);
+      transformTextNodeForMarkdownCriteria(scanningContext, elementNode, createHorizontalRuleNode);
       return;
     }
 
     if (elementNode.getChildren().length) {
-      const allCriteria = getAllMarkdownCriteria();
+      const allCriteria = getAllMarkdownCriteriaForParagraphs();
       const count = allCriteria.length;
+      scanningContext.joinedText = paragraphNode.getTextContent();
+
+      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 === true) {
-          if (!(firstChild != null && firstChildIsTextNode)) {
-            throw Error(`Expect paragraph containing only text nodes.`);
-          }
+        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.
+        if (patternMatchResults != null) {
+          scanningContext.markdownCriteria = criteria;
+          scanningContext.patternMatchResults = patternMatchResults; // Perform text transformation here.
 
-            transformTextNodeForElementNode(elementNode, scanningContext, createHorizontalRuleNode);
-            return;
-          }
+          transformTextNodeForMarkdownCriteria(scanningContext, elementNode, createHorizontalRuleNode);
+          return;
         }
       }
     }
   }
 }
 
-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;
+        }
 
+        scanningContext.textNodeWithOffset = {
+          node: lastTextNode,
+          offset: lastTextNode.getTextContent().length
+        };
+      }
 
-      resetScanningContext(scanningContext);
+      const patternMatchResults = getPatternMatchResultsForCriteria(criteria, scanningContext, elementNode);
 
-      if (root.getChildren().length !== countOfElementNodes) {
-        // The conversion added or removed an from root's children.
+      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,33 +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"),m=require("@lexical/list"),p=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 x=[{triggerKind:"space_trigger",triggerString:" "}],y={markdownFormatKind:null,regEx:/(?:)/,regExForAutoFormatting:/(?:)/,requiresParagraphStart:!1},A={...y,requiresParagraphStart:!0},B={...A,markdownFormatKind:"paragraphCodeBlock",regEx:/^(```)$/,regExForAutoFormatting:/^(```)([a-z]*)( )/},C=[{...y,markdownFormatKind:"strikethrough_italic_bold",regEx:/(~~_\*\*)(\s*\b)([^~~_\*\*][^\*\*_~~]*)(\b\s*)(\*\*_~~)/,regExForAutoFormatting:/(~~_\*\*)(\s*\b)([^~~_\*\*][^\*\*_~~]*)(\b\s*)(\*\*_~~)(\s)$/},
-{...y,markdownFormatKind:"italic_bold",regEx:/(_\*\*)(\s*\b)([^_\*\*][^\*\*_]*)(\b\s*)(\*\*_)/,regExForAutoFormatting:/(_\*\*)(\s*\b)([^_\*\*][^\*\*_]*)(\b\s*)(\*\*_)(\s)$/},{...y,markdownFormatKind:"strikethrough_italic",regEx:/(~~_)(\s*)([^~~_][^_~~]*)(\s*)(_~~)/,regExForAutoFormatting:/(~~_)(\s*)([^~~_][^_~~]*)(\s*)(_~~)(\s)$/},{...y,markdownFormatKind:"strikethrough_bold",regEx:/(~~\*\*)(\s*\b)([^~~\*\*][^\*\*~~]*)(\b\s*)(\*\*~~)/,regExForAutoFormatting:/(~~\*\*)(\s*\b)([^~~\*\*][^\*\*~~]*)(\b\s*)(\*\*~~)(\s)$/},
-{...y,markdownFormatKind:"code",regEx:/(`)([^`]*)(`)/,regExForAutoFormatting:/(`)(\s*\b)([^`]*)(\b\s*)(`)(\s)$/},{...y,markdownFormatKind:"italic",regEx:/(\*)([^\*]*)(\*)/,regExForAutoFormatting:/(\*)(\s*\b)([^\*]*)(\b\s*)(\*)(\s)$/},{...y,markdownFormatKind:"bold",regEx:/(\*\*)([^\*\*]*)(\*\*)/,regExForAutoFormatting:/(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)(\s)$/},{...y,markdownFormatKind:"bold",regEx:/(__)(\s*)([^__]*)(\s*)(__)/,regExForAutoFormatting:/(__)(\s*)([^__]*)(\s*)(__)(\s)$/},{...y,markdownFormatKind:"italic",
-regEx:/(_)([^_]*)(_)/,regExForAutoFormatting:/(_)()([^_]*)()(_)(\s)$/},{...y,markdownFormatKind:"underline",regEx:/(<u>)(\s*\b)([^<]*)(\b\s*)(<\/u>)/,regExForAutoFormatting:/(<u>)(\s*\b)([^<]*)(\b\s*)(<\/u>)(\s)$/},{...y,markdownFormatKind:"strikethrough",regEx:/(~~)([^~~]*)(~~)/,regExForAutoFormatting:/(~~)(\s*\b)([^~~]*)(\b\s*)(~~)(\s)$/},{...y,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:/^(\s{0,10})(?:- )/,regExForAutoFormatting:/^(\s{0,10})(?:- )/},{...A,markdownFormatKind:"paragraphUnorderedList",
-regEx:/^(\s{0,10})(?:\* )/,regExForAutoFormatting:/^(\s{0,10})(?:\* )/},{...A,markdownFormatKind:"paragraphOrderedList",regEx:/^(\s{0,10})(\d+)\.\s/,regExForAutoFormatting:/^(\s{0,10})(\d+)\.\s/},B,{...A,markdownFormatKind:"horizontalRule",regEx:/^(?:\*\*\*)$/,regExForAutoFormatting:/^(?:\*\*\* )/},{...A,markdownFormatKind:"horizontalRule",regEx:/^(?:---)$/,regExForAutoFormatting:/^(?:--- )/},...C];
-function E(b,d,e,a){return{currentElementNode:null,editor:b,isAutoFormatting:d,isWithinCodeBlock:!1,joinedText:null,markdownCriteria:{markdownFormatKind:"noTransformation",regEx:/(?:)/,regExForAutoFormatting:/(?:)/,requiresParagraphStart:null},patternMatchResults:{regExCaptureGroups:[]},textNodeWithOffset:e,triggerState:a}}
-function F(b,d,e,a){const c={regExCaptureGroups:[]};a=b.match(a);if(null!==a&&0<a.length&&(!1===d||0===a.index)&&(!1===e||a.index+a[0].length===b.length)){b=a.length;d=a.index;for(e=0;e<b;e++){const f=a[e];c.regExCaptureGroups.push({offsetInParent:d,text:f});0<e&&(d+=f.length)}return c}return null}function I(b){b=b.textNodeWithOffset;null==b&&w(82);return b}
-function J(b,d){var e=I(d);return null===e.node.getPreviousSibling()?(e=e.node.getTextContent(),F(e,!0,!1,d.isAutoFormatting?b.regExForAutoFormatting:b.regEx)):null}
-function K(b,d,e){var a=null,c=d.getChildren();const f=b.markdownCriteria,g=b.patternMatchResults;if(null!=f.markdownFormatKind)switch(f.markdownFormatKind){case "paragraphH1":a=u.$createHeadingNode("h1");a.append(...c);break;case "paragraphH2":a=u.$createHeadingNode("h2");a.append(...c);break;case "paragraphH3":a=u.$createHeadingNode("h3");a.append(...c);break;case "paragraphBlockQuote":a=u.$createQuoteNode();a.append(...c);break;case "paragraphUnorderedList":return L(d,c,g,"ul"),{newNode:null,shouldDelete:!1};
-case "paragraphOrderedList":return a=1<g.regExCaptureGroups.length?g.regExCaptureGroups[g.regExCaptureGroups.length-1].text:"1",b=b.isAutoFormatting?parseInt(a,10):void 0,L(d,c,g,"ol",b),{newNode:null,shouldDelete:!1};case "paragraphCodeBlock":if(!1===b.isAutoFormatting){if(0<b.patternMatchResults.regExCaptureGroups.length)return b.isWithinCodeBlock=!0!==b.isWithinCodeBlock,b.currentElementNode=null,{newNode:null,shouldDelete:!0};if(b.isWithinCodeBlock){if(null==b.currentElementNode)return d=k.$createCodeNode(),
-d.append(...c),b.currentElementNode=d,{newNode:d,shouldDelete:!1};null!=b.currentElementNode&&(d=b.currentElementNode,b=p.$createLineBreakNode(),d.append(b),c.length&&d.append(b),d.append(...c))}return{newNode:null,shouldDelete:!0}}null!=b.triggerState&&b.triggerState.isCodeBlock?a=p.$createParagraphNode():(a=k.$createCodeNode(),d=3<=g.regExCaptureGroups.length?g.regExCaptureGroups[2].text:null,null!=d&&0<d.length&&a.setLanguage(d));a.append(...c);break;case "horizontalRule":null!=e&&(c=e(),d.insertBefore(c))}return{newNode:a,
-shouldDelete:!1}}function L(b,d,e,a,c){const f=m.$createListItemNode();e=(e=e.regExCaptureGroups[0].text.match(/^\s*/))?Math.floor(e[0].length/4):0;f.append(...d);d=b.getPreviousSibling();m.$isListNode(d)&&d.getTag()===a?(d.append(f),b.remove()):(a=m.$createListNode(a,c),a.append(f),b.replace(a));e&&f.setIndent(e)}
-function M(b,d,e){if(null!=d.textNodeWithOffset){var a=I(d);0<d.patternMatchResults.regExCaptureGroups.length&&(a=a.node.spliceText(0,d.patternMatchResults.regExCaptureGroups[0].text.length,"",!0),""===a.getTextContent()&&(a.selectPrevious(),a.remove()))}const {newNode:c,shouldDelete:f}=K(d,b,e);f?b.remove():null!==c&&b.replace(c)}
-function N(b){switch(b){case "italic":case "bold":case "underline":case "strikethrough":case "code":return[b];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 Q(b,d,e,a,c){var f=c.patternMatchResults;const g=f.regExCaptureGroups;var h=g.length;if(b>=h||d>=h)return null;c=I(c).node.getParentOrThrow();h=f.regExCaptureGroups.length;2>h?f=0:(--h,f=f.regExCaptureGroups[h].offsetInParent+f.regExCaptureGroups[h].text.length);b=g[b];d=g[d];a=a?d.offsetInParent+d.text.length:d.offsetInParent;e=v.$findNodeWithOffsetFromJoinedText(e?b.offsetInParent+b.text.length:b.offsetInParent,f,1,c);a=v.$findNodeWithOffsetFromJoinedText(a,f,1,c);if(null==e||null==a)return null;
-c=p.$createRangeSelection();c.anchor.set(e.node.getKey(),e.offset,"text");c.focus.set(a.node.getKey(),a.offset,"text");return c}function R(b,d,e){const a=e.patternMatchResults.regExCaptureGroups;e=Q(b,d,!1,!0,e);if(null!=e&&(p.$setSelection(e),e=p.$getSelection(),null!=e&&p.$isRangeSelection(e)&&!1===e.isCollapsed())){e.removeText();e=0;const c=a.length;for(let f=b;f<c;f++){const g=a[f];f>b&&(g.offsetInParent-=e);f<=d&&(e+=g.text.length,g.text="")}}}
-function S(b){var d=b.patternMatchResults.regExCaptureGroups.length;2>d||(--d,b=Q(d,d,!0,!0,b),null!=b&&p.$setSelection(b))}
-function T(b,d,e){b.update(()=>{if(!0===d.markdownCriteria.requiresParagraphStart){var a=I(d).node.getParentOrThrow();M(a,d,e)}else if(a=d.markdownCriteria,null!=a.markdownFormatKind){var c=N(a.markdownFormatKind);if(null!=c){if(a=c,7===d.patternMatchResults.regExCaptureGroups.length){R(5,5,d);R(1,1,d);c=d.patternMatchResults.regExCaptureGroups;3<c.length||w(65);if(0!==c[3].text.length&&(c=Q(3,3,!1,!0,d),null!=c&&(p.$setSelection(c),c=p.$getSelection(),p.$isRangeSelection(c))))for(var f=0;f<a.length;f++)c.formatText(a[f]);
-S(d)}}else if("link"===a.markdownFormatKind&&(a=d.patternMatchResults.regExCaptureGroups,7===a.length&&(f=a[2].text,a=a[4].text,0!==f.length&&0!==a.length))){R(1,5,d);c=d.patternMatchResults.regExCaptureGroups;if(!(1>=c.length)){f={offsetInParent:c[1].offsetInParent,text:f};var g=Q(1,1,!1,!1,d);if(null!=g&&(p.$setSelection(g),g=p.$getSelection(),null!=g&&p.$isRangeSelection(g)&&g.isCollapsed())){g.insertText(f.text);c.splice(1,0,f);f=f.text.length;g=c.length;for(let h=2;h<g;h++)c[h].offsetInParent+=
-f}}c=Q(1,1,!1,!0,d);null!=c&&(p.$setSelection(c),d.editor.dispatchCommand(t.TOGGLE_LINK_COMMAND,a),S(d))}}},{tag:"history-push"})}
-function U(b,d){let e=null;b.getEditorState().read(()=>{var a=p.$getSelection();if(p.$isRangeSelection(a)){var c=a.anchor.getNode();a=p.$isTextNode(c)?{node:c,offset:a.anchor.offset}:null}else a=null;if(null!==a){a=E(b,!0,a,d);a:{c=!1===d.isParentAListItemNode?D:C;const h=a.triggerState,r=c.length;for(let n=0;n<r;n++){const l=c[n];if(null!=h&&!1===h.isCodeBlock||"paragraphCodeBlock"===l.markdownFormatKind){var f=l,g=a;if(!0===f.requiresParagraphStart)f=J(f,g);else{if(null==g.joinedText){const q=I(g).node.getParentOrThrow();
-p.$isElementNode(q)?null==g.joinedText&&(g.joinedText=v.$joinTextNodesInElementNode(q,"\u0004",I(g))):w(52,q.__key)}f=F(g.joinedText,!1,!0,f.regExForAutoFormatting)}if(null!=f){c={markdownCriteria:l,patternMatchResults:f};break a}}}c={markdownCriteria:null,patternMatchResults:null}}null!==c.markdownCriteria&&null!==c.patternMatchResults&&(e=a,e.markdownCriteria=c.markdownCriteria,e.patternMatchResults=c.patternMatchResults)}});return e}
-function V(b){let d=null;b.read(()=>{const e=p.$getSelection();if(p.$isRangeSelection(e)&&e.isCollapsed()){var a=e.anchor.getNode(),c=a.getParent(),f=m.$isListItemNode(c);d={anchorOffset:e.anchor.offset,hasParentNode:null!==c,isCodeBlock:k.$isCodeNode(a),isParentAListItemNode:f,isSelectionCollapsed:!0,isSimpleText:p.$isTextNode(a)&&a.isSimpleText(),nodeKey:a.getKey(),textContent:a.getTextContent()}}});return d}
-exports.$convertFromMarkdownString=function(b,d,e){if(b.length){var a=[];b=b.split("\n");var c=b.length;for(var f=0;f<c;f++)0<b[f].length?a.push(p.$createParagraphNode().append(p.$createTextNode(b[f]))):a.push(p.$createParagraphNode());a.length?(b=p.$getRoot(),b.clear(),b.append(...a),a=b):a=null}else a=null;if(null!=a)for(d=E(d,!1,null,null),a=p.$getRoot(),b=!1,c=0;!b;){b=!0;f=a.getChildren();const q=f.length;for(let z=c;z<q;z++){var g=f[z];if(p.$isElementNode(g)){var h=d,r=e,n=g.getTextContent();
-if(p.$isParagraphNode(g)){var l=g.getFirstChild();const O=p.$isTextNode(l);if(!0===h.isWithinCodeBlock)null!=l&&O&&(h.textNodeWithOffset={node:l,offset:0},l=F(n,!0,!1,h.isAutoFormatting?B.regExForAutoFormatting:B.regEx),null!=l&&(h.patternMatchResults=l)),h.markdownCriteria=B,M(g,h,r);else if(g.getChildren().length){n=D.length;for(let G=0;G<n;G++){const H=D[G];if(!0===H.requiresParagraphStart){null!=l&&O||w(80);h.textNodeWithOffset={node:l,offset:0};h.joinedText=g.getTextContent();const P=J(H,h);
-if(null!=P){h.markdownCriteria=H;h.patternMatchResults=P;M(g,h,r);break}}}}}}h=d;h.joinedText="";h.markdownCriteria={markdownFormatKind:"noTransformation",regEx:/(?:)/,regExForAutoFormatting:/(?:)/,requiresParagraphStart:null};h.patternMatchResults={regExCaptureGroups:[]};h.triggerState=null;h.textNodeWithOffset=null;if(a.getChildren().length!==q){c=z;b=!1;break}}}};
-exports.registerMarkdownShortcuts=function(b,d){let e=null;return b.registerUpdateListener(({tags:a})=>{if(!1===a.has("historic")){a=V(b.getEditorState());if(null==a)var c=null;else a:{c=a;var f=e;if(null==c||null==f)c=null;else{var g=x.length;for(let h=0;h<g;h++){const r=x[h].triggerString,n=r.length,l=c.textContent.length,q=c.anchorOffset-n;if(!1===(!0===c.hasParentNode&&c.isSimpleText&&c.isSelectionCollapsed&&c.anchorOffset!==f.anchorOffset&&0<=q&&q+n<=l&&c.textContent.substr(q,n)===r&&c.textContent!==
-f.textContent)){c=null;break a}}c=U(b,c)}}null!=c&&T(b,c,d);e=a}else e=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.2.0",
+  "version": "0.2.3",
   "main": "LexicalMarkdown.js",
   "peerDependencies": {
-    "lexical": "0.2.0"
+    "lexical": "0.2.3"
   },
   "dependencies": {
-    "@lexical/utils": "0.2.0",
-    "@lexical/code": "0.2.0",
-    "@lexical/text": "0.2.0",
-    "@lexical/rich-text": "0.2.0",
-    "@lexical/list": "0.2.0",
-    "@lexical/link": "0.2.0"
+    "@lexical/utils": "0.2.3",
+    "@lexical/code": "0.2.3",
+    "@lexical/text": "0.2.3",
+    "@lexical/rich-text": "0.2.3",
+    "@lexical/list": "0.2.3",
+    "@lexical/link": "0.2.3"
   },
   "repository": {
     "type": "git",