@lexical/markdown 0.1.19 → 0.2.0

package/LexicalMarkdown.dev.js

@@ -6,9 +6,9 @@
  */
 'use strict';
 
-var lexical = require('lexical');
 var code = require('@lexical/code');
 var list = require('@lexical/list');
+var lexical = require('lexical');
 var link = require('@lexical/link');
 var richText = require('@lexical/rich-text');
 var text = require('@lexical/text');
@@ -23,7 +23,7 @@ var text = require('@lexical/text');
  */
 /*
    How to add a new syntax to capture and transform.
-   1. Create a new enumeration by adding to AutoFormatKind.
+   1. Create a new enumeration by adding to MarkdownFormatKind.
    2. Add a new criteria with a regEx pattern. See markdownStrikethrough as an example.
    3. Add your block criteria (e.g. '# ') to allMarkdownCriteria or 
       your text criteria (e.g. *MyItalic*) to allMarkdownCriteriaForTextNodes.
@@ -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,10 +49,10 @@ 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 = {
-  autoFormatKind: null,
+  markdownFormatKind: null,
   regEx: /(?:)/,
   regExForAutoFormatting: /(?:)/,
   requiresParagraphStart: false
@@ -61,101 +61,133 @@ const paragraphStartBase = { ...autoFormatBase,
   requiresParagraphStart: true
 };
 const markdownHeader1 = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphH1',
-  regEx: /^(?:#)/,
+  markdownFormatKind: 'paragraphH1',
+  regEx: /^(?:# )/,
   regExForAutoFormatting: /^(?:# )/
 };
 const markdownHeader2 = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphH2',
-  regEx: /^(?:##)/,
+  markdownFormatKind: 'paragraphH2',
+  regEx: /^(?:## )/,
   regExForAutoFormatting: /^(?:## )/
 };
 const markdownHeader3 = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphH2',
-  regEx: /^(?:###)/,
+  markdownFormatKind: 'paragraphH2',
+  regEx: /^(?:### )/,
   regExForAutoFormatting: /^(?:### )/
 };
 const markdownBlockQuote = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphBlockQuote',
-  regEx: /^(?:>)/,
+  markdownFormatKind: 'paragraphBlockQuote',
+  regEx: /^(?:> )/,
   regExForAutoFormatting: /^(?:> )/
 };
 const markdownUnorderedListDash = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphUnorderedList',
-  regEx: /^(?:- )/,
-  regExForAutoFormatting: /^(?:- )/
+  markdownFormatKind: 'paragraphUnorderedList',
+  regEx: /^(\s{0,10})(?:- )/,
+  regExForAutoFormatting: /^(\s{0,10})(?:- )/
 };
 const markdownUnorderedListAsterisk = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphUnorderedList',
-  regEx: /^(?:\* )/,
-  regExForAutoFormatting: /^(?:\* )/
+  markdownFormatKind: 'paragraphUnorderedList',
+  regEx: /^(\s{0,10})(?:\* )/,
+  regExForAutoFormatting: /^(\s{0,10})(?:\* )/
 };
 const markdownCodeBlock = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphCodeBlock',
+  markdownFormatKind: 'paragraphCodeBlock',
   regEx: /^(```)$/,
   regExForAutoFormatting: /^(```)([a-z]*)( )/
 };
 const markdownOrderedList = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphOrderedList',
-  regEx: /^(\d+)\.\s/,
-  regExForAutoFormatting: /^(\d+)\.\s/
+  markdownFormatKind: 'paragraphOrderedList',
+  regEx: /^(\s{0,10})(\d+)\.\s/,
+  regExForAutoFormatting: /^(\s{0,10})(\d+)\.\s/
 };
 const markdownHorizontalRule = { ...paragraphStartBase,
-  autoFormatKind: 'horizontalRule',
+  markdownFormatKind: 'horizontalRule',
   regEx: /^(?:\*\*\*)$/,
   regExForAutoFormatting: /^(?:\*\*\* )/
 };
 const markdownHorizontalRuleUsingDashes = { ...paragraphStartBase,
-  autoFormatKind: 'horizontalRule',
+  markdownFormatKind: 'horizontalRule',
   regEx: /^(?:---)$/,
   regExForAutoFormatting: /^(?:--- )/
 };
+const markdownInlineCode = { ...autoFormatBase,
+  markdownFormatKind: 'code',
+  regEx: /(`)([^`]*)(`)/,
+  regExForAutoFormatting: /(`)(\s*\b)([^`]*)(\b\s*)(`)(\s)$/
+};
 const markdownItalic = { ...autoFormatBase,
-  autoFormatKind: 'italic',
-  regEx: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*)/,
+  markdownFormatKind: 'italic',
+  regEx: /(\*)([^\*]*)(\*)/,
   regExForAutoFormatting: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*)(\s)$/
 };
 const markdownBold = { ...autoFormatBase,
-  autoFormatKind: 'bold',
-  regEx: /(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)/,
+  markdownFormatKind: 'bold',
+  regEx: /(\*\*)([^\*\*]*)(\*\*)/,
   regExForAutoFormatting: /(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)(\s)$/
 };
-const markdownBoldWithUnderlines = { ...autoFormatBase,
-  autoFormatKind: 'bold',
+const markdownBold2 = { ...autoFormatBase,
+  markdownFormatKind: 'bold',
   regEx: /(__)(\s*)([^__]*)(\s*)(__)/,
   regExForAutoFormatting: /(__)(\s*)([^__]*)(\s*)(__)(\s)$/
 };
-const markdownBoldItalic = { ...autoFormatBase,
-  autoFormatKind: '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,
-  autoFormatKind: 'underline',
+  markdownFormatKind: 'underline',
   regEx: /(\<u\>)(\s*\b)([^\<]*)(\b\s*)(\<\/u\>)/,
   regExForAutoFormatting: /(\<u\>)(\s*\b)([^\<]*)(\b\s*)(\<\/u\>)(\s)$/
 };
 const markdownStrikethrough = { ...autoFormatBase,
-  autoFormatKind: 'strikethrough',
-  regEx: /(~~)(\s*\b)([^~~]*)(\b\s*)(~~)/,
+  markdownFormatKind: 'strikethrough',
+  regEx: /(~~)([^~~]*)(~~)/,
   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,
-  autoFormatKind: 'link',
+  markdownFormatKind: 'link',
   regEx: /(\[)(.+)(\]\()([^ ]+)(?: \"(?:.+)\")?(\))/,
   regExForAutoFormatting: /(\[)(.+)(\]\()([^ ]+)(?: \"(?:.+)\")?(\))(\s)$/
 };
-const allMarkdownCriteriaForTextNodes = [markdownBoldItalic, markdownItalic, markdownBold, markdownBoldWithUnderlines, fakeMarkdownUnderline, markdownStrikethrough, markdownLink];
+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.
+fakeMarkdownUnderline, markdownStrikethrough, markdownLink];
 const allMarkdownCriteria = [markdownHeader1, markdownHeader2, markdownHeader3, markdownBlockQuote, markdownUnorderedListDash, markdownUnorderedListAsterisk, markdownOrderedList, markdownCodeBlock, markdownHorizontalRule, markdownHorizontalRuleUsingDashes, ...allMarkdownCriteriaForTextNodes];
 function getInitialScanningContext(editor, isAutoFormatting, textNodeWithOffset, triggerState) {
   return {
+    currentElementNode: null,
     editor,
     isAutoFormatting,
+    isWithinCodeBlock: false,
     joinedText: null,
     markdownCriteria: {
-      autoFormatKind: 'noTransformation',
+      markdownFormatKind: 'noTransformation',
       regEx: /(?:)/,
       // Empty reg ex.
       regExForAutoFormatting: /(?:)/,
@@ -172,7 +204,7 @@ function getInitialScanningContext(editor, isAutoFormatting, textNodeWithOffset,
 function resetScanningContext(scanningContext) {
   scanningContext.joinedText = '';
   scanningContext.markdownCriteria = {
-    autoFormatKind: 'noTransformation',
+    markdownFormatKind: 'noTransformation',
     regEx: /(?:)/,
     // Empty reg ex.
     regExForAutoFormatting: /(?:)/,
@@ -186,6 +218,13 @@ function resetScanningContext(scanningContext) {
   scanningContext.textNodeWithOffset = null;
   return scanningContext;
 }
+function getCodeBlockCriteria() {
+  return markdownCodeBlock;
+}
+function getPatternMatchResultsForCodeBlock(scanningContext, text) {
+  const markdownCriteria = getCodeBlockCriteria();
+  return getPatternMatchResultsWithRegEx(text, true, false, scanningContext.isAutoFormatting ? markdownCriteria.regExForAutoFormatting : markdownCriteria.regEx);
+}
 
 function getPatternMatchResultsWithRegEx(textToSearch, matchMustAppearAtStartOfString, matchMustAppearAtEndOfString, regEx) {
   const patternMatchResults = {
@@ -217,6 +256,9 @@ function getPatternMatchResultsWithRegEx(textToSearch, matchMustAppearAtStartOfS
   return null;
 }
 
+function hasPatternMatchResults(scanningContext) {
+  return scanningContext.patternMatchResults.regExCaptureGroups.length > 0;
+}
 function getTextNodeWithOffsetOrThrow(scanningContext) {
   const textNodeWithOffset = scanningContext.textNodeWithOffset;
 
@@ -233,7 +275,7 @@ function getPatternMatchResultsForParagraphs(markdownCriteria, scanningContext)
 
   if (textNodeWithOffset.node.getPreviousSibling() === null) {
     const textToSearch = textNodeWithOffset.node.getTextContent();
-    return getPatternMatchResultsWithRegEx(textToSearch, true, false, markdownCriteria.regExForAutoFormatting);
+    return getPatternMatchResultsWithRegEx(textToSearch, true, false, scanningContext.isAutoFormatting ? markdownCriteria.regExForAutoFormatting : markdownCriteria.regEx);
   }
 
   return null;
@@ -259,63 +301,124 @@ function getPatternMatchResultsForText(markdownCriteria, scanningContext) {
 
 function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNode) {
   let newNode = null;
+  const shouldDelete = false;
   const children = element.getChildren();
   const markdownCriteria = scanningContext.markdownCriteria;
   const patternMatchResults = scanningContext.patternMatchResults;
 
-  if (markdownCriteria.autoFormatKind != null) {
-    switch (markdownCriteria.autoFormatKind) {
+  if (markdownCriteria.markdownFormatKind != null) {
+    switch (markdownCriteria.markdownFormatKind) {
       case 'paragraphH1':
         {
           newNode = richText.$createHeadingNode('h1');
           newNode.append(...children);
-          return newNode;
+          return {
+            newNode,
+            shouldDelete
+          };
         }
 
       case 'paragraphH2':
         {
           newNode = richText.$createHeadingNode('h2');
           newNode.append(...children);
-          return newNode;
+          return {
+            newNode,
+            shouldDelete
+          };
         }
 
       case 'paragraphH3':
         {
           newNode = richText.$createHeadingNode('h3');
           newNode.append(...children);
-          return newNode;
+          return {
+            newNode,
+            shouldDelete
+          };
         }
 
       case 'paragraphBlockQuote':
         {
           newNode = richText.$createQuoteNode();
           newNode.append(...children);
-          return newNode;
+          return {
+            newNode,
+            shouldDelete
+          };
         }
 
       case 'paragraphUnorderedList':
         {
-          newNode = list.$createListNode('ul');
-          const listItem = list.$createListItemNode();
-          listItem.append(...children);
-          newNode.append(listItem);
-          return newNode;
+          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';
-          const start = parseInt(startAsString, 10);
-          newNode = list.$createListNode('ol', start);
-          const listItem = list.$createListItemNode();
-          listItem.append(...children);
-          newNode.append(listItem);
-          return newNode;
+          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 = hasPatternMatchResults(scanningContext);
+
+            if (shouldToggle) {
+              scanningContext.isWithinCodeBlock = scanningContext.isWithinCodeBlock !== true; // When toggling, always clear the code block element node.
+
+              scanningContext.currentElementNode = null;
+              return {
+                newNode: null,
+                shouldDelete: true
+              };
+            }
+
+            if (scanningContext.isWithinCodeBlock) {
+              // Create the code block and return it to the caller.
+              if (scanningContext.currentElementNode == null) {
+                const newCodeBlockNode = code.$createCodeNode();
+                newCodeBlockNode.append(...children);
+                scanningContext.currentElementNode = newCodeBlockNode;
+                return {
+                  newNode: newCodeBlockNode,
+                  shouldDelete: false
+                };
+              } // Build up the code block with a line break and the children.
+
+
+              if (scanningContext.currentElementNode != null) {
+                const codeBlockNode = scanningContext.currentElementNode;
+                const lineBreakNode = lexical.$createLineBreakNode();
+                codeBlockNode.append(lineBreakNode);
+
+                if (children.length) {
+                  codeBlockNode.append(lineBreakNode);
+                }
+
+                codeBlockNode.append(...children);
+              }
+            }
+
+            return {
+              newNode: null,
+              shouldDelete: true
+            };
+          }
+
           if (scanningContext.triggerState != null && scanningContext.triggerState.isCodeBlock) {
             newNode = lexical.$createParagraphNode();
           } else {
@@ -328,53 +431,94 @@ function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNod
           }
 
           newNode.append(...children);
-          return newNode;
+          return {
+            newNode,
+            shouldDelete
+          };
         }
 
       case 'horizontalRule':
         {
-          // return null for newNode. Insert the HR here.
-          const horizontalRuleNode = createHorizontalRuleNode();
-          element.insertBefore(horizontalRuleNode);
+          if (createHorizontalRuleNode != null) {
+            // return null for newNode. Insert the HR here.
+            const horizontalRuleNode = createHorizontalRuleNode();
+            element.insertBefore(horizontalRuleNode);
+          }
+
           break;
         }
     }
   }
 
-  return newNode;
+  return {
+    newNode,
+    shouldDelete
+  };
 }
 
-function transformTextNodeForParagraphs(scanningContext, createHorizontalRuleNode) {
-  const textNodeWithOffset = getTextNodeWithOffsetOrThrow(scanningContext);
-  const element = textNodeWithOffset.node.getParentOrThrow();
-  const text = scanningContext.patternMatchResults.regExCaptureGroups[0].text; // Remove the text which we matched.
+function createListOrMergeWithPrevious(element, children, patternMatchResults, tag, start) {
+  const listItem = list.$createListItemNode();
+  const indentMatch = patternMatchResults.regExCaptureGroups[0].text.match(/^\s*/);
+  const indent = indentMatch ? Math.floor(indentMatch[0].length / 4) : 0;
+  listItem.append(...children); // Checking if previous element is a list, and if so append
+  // new list item inside instead of creating new list
+
+  const prevElement = element.getPreviousSibling();
+
+  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);
+  }
+}
+
+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);
+      const textNode = textNodeWithOffset.node.spliceText(0, text.length, '', true);
 
-  if (textNode.getTextContent() === '') {
-    textNode.selectPrevious();
-    textNode.remove();
+      if (textNode.getTextContent() === '') {
+        textNode.selectPrevious();
+        textNode.remove();
+      }
+    }
   } // Transform the current element kind to the new element kind.
 
 
-  const elementNode = getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNode);
+  const {
+    newNode,
+    shouldDelete
+  } = getNewNodeForCriteria(scanningContext, elementNode, createHorizontalRuleNode);
 
-  if (elementNode !== null) {
-    element.replace(elementNode);
+  if (shouldDelete) {
+    elementNode.remove();
+  } else if (newNode !== null) {
+    elementNode.replace(newNode);
   }
 }
 function transformTextNodeForText(scanningContext) {
   const markdownCriteria = scanningContext.markdownCriteria;
 
-  if (markdownCriteria.autoFormatKind != null) {
-    const formatting = getTextFormatType(markdownCriteria.autoFormatKind);
+  if (markdownCriteria.markdownFormatKind != null) {
+    const formatting = getTextFormatType(markdownCriteria.markdownFormatKind);
 
     if (formatting != null) {
       transformTextNodeWithFormatting(formatting, scanningContext);
       return;
     }
 
-    if (markdownCriteria.autoFormatKind === 'link') {
+    if (markdownCriteria.markdownFormatKind === 'link') {
       transformTextNodeWithLink(scanningContext);
     }
   }
@@ -466,17 +610,33 @@ function getJoinedTextLength(patternMatchResults) {
   return patternMatchResults.regExCaptureGroups[lastGroupIndex].offsetInParent + patternMatchResults.regExCaptureGroups[lastGroupIndex].text.length;
 }
 
-function getTextFormatType(autoFormatKind) {
-  switch (autoFormatKind) {
+function getTextFormatType(markdownFormatKind) {
+  switch (markdownFormatKind) {
     case 'italic':
     case 'bold':
     case 'underline':
     case 'strikethrough':
-      return [autoFormatKind];
+    case 'code':
+      return [markdownFormatKind];
+
+    case 'strikethrough_italic_bold':
+      {
+        return ['strikethrough', 'italic', 'bold'];
+      }
 
-    case 'bold_italic':
+    case 'italic_bold':
       {
-        return ['bold', 'italic'];
+        return ['italic', 'bold'];
+      }
+
+    case 'strikethrough_italic':
+      {
+        return ['strikethrough', 'italic'];
+      }
+
+    case 'strikethrough_bold':
+      {
+        return ['strikethrough', 'bold'];
       }
   }
 
@@ -643,7 +803,8 @@ function getAllMarkdownCriteria() {
 }
 function transformTextNodeForMarkdownCriteria(scanningContext, createHorizontalRuleNode) {
   if (scanningContext.markdownCriteria.requiresParagraphStart === true) {
-    transformTextNodeForParagraphs(scanningContext, createHorizontalRuleNode);
+    const elementNode = getTextNodeWithOffsetOrThrow(scanningContext).node.getParentOrThrow();
+    transformTextNodeForElementNode(elementNode, scanningContext, createHorizontalRuleNode);
   } else {
     transformTextNodeForText(scanningContext);
   }
@@ -689,7 +850,7 @@ function getCriteriaWithPatternMatchResults(markdownCriteriaArray, scanningConte
   for (let i = 0; i < count; i++) {
     const markdownCriteria = markdownCriteriaArray[i]; // Skip code block nodes, unless the autoFormatKind calls for toggling the code block.
 
-    if (currentTriggerState != null && currentTriggerState.isCodeBlock === false || markdownCriteria.autoFormatKind === 'paragraphCodeBlock') {
+    if (currentTriggerState != null && currentTriggerState.isCodeBlock === false || markdownCriteria.markdownFormatKind === 'paragraphCodeBlock') {
       const patternMatchResults = getPatternMatchResultsForCriteria(markdownCriteria, scanningContext);
 
       if (patternMatchResults != null) {
@@ -776,7 +937,7 @@ function findScanningContext(editor, currentTriggerState, priorTriggerState) {
     const currentTextContentLength = currentTriggerState.textContent.length;
     const triggerOffset = currentTriggerState.anchorOffset - triggerStringLength;
 
-    if ((currentTriggerState.hasParentNode === true && currentTriggerState.isSimpleText && currentTriggerState.isSelectionCollapsed && currentTriggerState.nodeKey === priorTriggerState.nodeKey && 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.
+    if ((currentTriggerState.hasParentNode === true && currentTriggerState.isSimpleText && currentTriggerState.isSelectionCollapsed && currentTriggerState.anchorOffset !== priorTriggerState.anchorOffset && triggerOffset >= 0 && triggerOffset + triggerStringLength <= currentTextContentLength && currentTriggerState.textContent.substr(triggerOffset, triggerStringLength) === triggerString && // Some code differentiation needed if trigger kind is not a simple space character.
     currentTriggerState.textContent !== priorTriggerState.textContent) === false) {
       return null;
     }
@@ -794,62 +955,125 @@ function findScanningContext(editor, currentTriggerState, priorTriggerState) {
  * 
  */
 function convertStringToLexical(text, editor) {
-  const nodes = text.split('\n').map(splitText => lexical.$createParagraphNode().append(lexical.$createTextNode(splitText)));
-  const root = lexical.$getRoot();
-  root.clear();
-  root.append(...nodes);
-}
+  if (!text.length) {
+    return null;
+  }
 
-function convertElementNodeContainingMarkdown(scanningContext, elementNode) {
-  // Handle code block to be done.
-  // Handle paragraph nodes below.
-  if (lexical.$isParagraphNode(elementNode)) {
-    const paragraphNode = elementNode;
-    const allCriteria = getAllMarkdownCriteria();
-    const count = allCriteria.length;
+  const nodes = [];
+  const splitLines = text.split('\n');
+  const splitLinesCount = splitLines.length;
 
-    for (let i = 0; i < count; i++) {
-      const criteria = allCriteria[i];
+  for (let i = 0; i < splitLinesCount; i++) {
+    if (splitLines[i].length > 0) {
+      nodes.push(lexical.$createParagraphNode().append(lexical.$createTextNode(splitLines[i])));
+    } else {
+      nodes.push(lexical.$createParagraphNode());
+    }
+  }
 
-      if (criteria.requiresParagraphStart === true) {
-        const firstChild = paragraphNode.getFirstChild();
+  if (nodes.length) {
+    const root = lexical.$getRoot();
+    root.clear();
+    root.append(...nodes);
+    return root;
+  }
 
-        if (!lexical.$isTextNode(firstChild)) {
-          throw Error(`Expect paragraph containing only text nodes.`);
-        }
+  return null;
+}
+
+function convertElementNodeContainingMarkdown(scanningContext, elementNode, createHorizontalRuleNode) {
+  const textContent = elementNode.getTextContent(); // Handle paragraph nodes below.
+
+  if (lexical.$isParagraphNode(elementNode)) {
+    const paragraphNode = elementNode;
+    const firstChild = paragraphNode.getFirstChild();
+    const firstChildIsTextNode = lexical.$isTextNode(firstChild); // Handle conversion to code block.
 
+    if (scanningContext.isWithinCodeBlock === true) {
+      if (firstChild != null && firstChildIsTextNode) {
+        // Test if we encounter ending code block.
         scanningContext.textNodeWithOffset = {
           node: firstChild,
           offset: 0
         };
-        scanningContext.joinedText = paragraphNode.getTextContent();
-        const patternMatchResults = getPatternMatchResultsForParagraphs(criteria, scanningContext);
+        const patternMatchResults = getPatternMatchResultsForCodeBlock(scanningContext, textContent);
 
         if (patternMatchResults != null) {
-          // Lazy fill-in the particular format criteria and any matching result information.
-          scanningContext.markdownCriteria = criteria;
-          scanningContext.patternMatchResults = patternMatchResults; // Todo: perform text transformation here.
+          // Toggle transform to or from code block.
+          scanningContext.patternMatchResults = patternMatchResults;
+        }
+      }
+
+      scanningContext.markdownCriteria = getCodeBlockCriteria(); // Perform text transformation here.
+
+      transformTextNodeForElementNode(elementNode, scanningContext, createHorizontalRuleNode);
+      return;
+    }
+
+    if (elementNode.getChildren().length) {
+      const allCriteria = getAllMarkdownCriteria();
+      const count = allCriteria.length;
+
+      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.`);
+          }
+
+          scanningContext.textNodeWithOffset = {
+            node: firstChild,
+            offset: 0
+          };
+          scanningContext.joinedText = paragraphNode.getTextContent();
+          const patternMatchResults = getPatternMatchResultsForParagraphs(criteria, 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.
+
+            transformTextNodeForElementNode(elementNode, scanningContext, createHorizontalRuleNode);
+            return;
+          }
         }
       }
     }
   }
 }
 
-function convertMarkdownForElementNodes(elementNodes, editor) {
+function convertMarkdownForElementNodes(editor, createHorizontalRuleNode) {
   // Please see the declaration of ScanningContext for a detailed explanation.
   const scanningContext = getInitialScanningContext(editor, false, null, null);
-  const count = elementNodes.length;
+  const root = lexical.$getRoot();
+  let done = false;
+  let startIndex = 0;
 
-  for (let i = 0; i < count; i++) {
-    const elementNode = elementNodes[i];
+  while (!done) {
+    done = true;
+    const elementNodes = root.getChildren();
+    const countOfElementNodes = elementNodes.length;
 
-    if (lexical.$isElementNode(elementNode) && elementNode.getTextContent().length && elementNode.getChildren().length) {
-      convertElementNodeContainingMarkdown(scanningContext, elementNode);
-    } // Reset the scanning information that relates to the particular element node.
+    for (let i = startIndex; i < countOfElementNodes; i++) {
+      const elementNode = elementNodes[i];
 
+      if (lexical.$isElementNode(elementNode)) {
+        convertElementNodeContainingMarkdown(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
 
-    resetScanningContext(scanningContext);
-  }
 }
 
 /**
@@ -885,8 +1109,9 @@ function registerMarkdownShortcuts(editor, createHorizontalRuleNode) {
   });
 }
 function $convertFromMarkdownString(markdownString, editor, createHorizontalRuleNode) {
-  convertStringToLexical(markdownString);
-  convertMarkdownForElementNodes(lexical.$getRoot().getChildren(), editor);
+  if (convertStringToLexical(markdownString) != null) {
+    convertMarkdownForElementNodes(editor, createHorizontalRuleNode);
+  }
 }
 
 exports.$convertFromMarkdownString = $convertFromMarkdownString;

package/LexicalMarkdown.prod.js

@@ -4,26 +4,33 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var h=require("lexical"),n=require("@lexical/code"),p=require("@lexical/list"),r=require("@lexical/link"),t=require("@lexical/rich-text"),u=require("@lexical/text");function w(e){throw Error(`Minified Lexical error #${e}; 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={autoFormatKind:null,regEx:/(?:)/,regExForAutoFormatting:/(?:)/,requiresParagraphStart:!1},z={...y,requiresParagraphStart:!0},A=[{...y,autoFormatKind:"bold_italic",regEx:/(\*\*\*)(\s*\b)([^\*\*\*]*)(\b\s*)(\*\*\*)/,regExForAutoFormatting:/(\*\*\*)(\s*\b)([^\*\*\*]*)(\b\s*)(\*\*\*)(\s)$/},{...y,autoFormatKind:"italic",regEx:/(\*)(\s*\b)([^\*]*)(\b\s*)(\*)/,regExForAutoFormatting:/(\*)(\s*\b)([^\*]*)(\b\s*)(\*)(\s)$/},{...y,autoFormatKind:"bold",
-regEx:/(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)/,regExForAutoFormatting:/(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)(\s)$/},{...y,autoFormatKind:"bold",regEx:/(__)(\s*)([^__]*)(\s*)(__)/,regExForAutoFormatting:/(__)(\s*)([^__]*)(\s*)(__)(\s)$/},{...y,autoFormatKind:"underline",regEx:/(<u>)(\s*\b)([^<]*)(\b\s*)(<\/u>)/,regExForAutoFormatting:/(<u>)(\s*\b)([^<]*)(\b\s*)(<\/u>)(\s)$/},{...y,autoFormatKind:"strikethrough",regEx:/(~~)(\s*\b)([^~~]*)(\b\s*)(~~)/,regExForAutoFormatting:/(~~)(\s*\b)([^~~]*)(\b\s*)(~~)(\s)$/},
-{...y,autoFormatKind:"link",regEx:/(\[)(.+)(\]\()([^ ]+)(?: "(?:.+)")?(\))/,regExForAutoFormatting:/(\[)(.+)(\]\()([^ ]+)(?: "(?:.+)")?(\))(\s)$/}],B=[{...z,autoFormatKind:"paragraphH1",regEx:/^(?:#)/,regExForAutoFormatting:/^(?:# )/},{...z,autoFormatKind:"paragraphH2",regEx:/^(?:##)/,regExForAutoFormatting:/^(?:## )/},{...z,autoFormatKind:"paragraphH2",regEx:/^(?:###)/,regExForAutoFormatting:/^(?:### )/},{...z,autoFormatKind:"paragraphBlockQuote",regEx:/^(?:>)/,regExForAutoFormatting:/^(?:> )/},
-{...z,autoFormatKind:"paragraphUnorderedList",regEx:/^(?:- )/,regExForAutoFormatting:/^(?:- )/},{...z,autoFormatKind:"paragraphUnorderedList",regEx:/^(?:\* )/,regExForAutoFormatting:/^(?:\* )/},{...z,autoFormatKind:"paragraphOrderedList",regEx:/^(\d+)\.\s/,regExForAutoFormatting:/^(\d+)\.\s/},{...z,autoFormatKind:"paragraphCodeBlock",regEx:/^(```)$/,regExForAutoFormatting:/^(```)([a-z]*)( )/},{...z,autoFormatKind:"horizontalRule",regEx:/^(?:\*\*\*)$/,regExForAutoFormatting:/^(?:\*\*\* )/},{...z,autoFormatKind:"horizontalRule",
-regEx:/^(?:---)$/,regExForAutoFormatting:/^(?:--- )/},...A];function C(e,c,f,a){return{editor:e,isAutoFormatting:c,joinedText:null,markdownCriteria:{autoFormatKind:"noTransformation",regEx:/(?:)/,regExForAutoFormatting:/(?:)/,requiresParagraphStart:null},patternMatchResults:{regExCaptureGroups:[]},textNodeWithOffset:f,triggerState:a}}
-function D(e,c,f,a){const b={regExCaptureGroups:[]};a=e.match(a);if(null!==a&&0<a.length&&(!1===c||0===a.index)&&(!1===f||a.index+a[0].length===e.length)){e=a.length;c=a.index;for(f=0;f<e;f++){const d=a[f];b.regExCaptureGroups.push({offsetInParent:c,text:d});0<f&&(c+=d.length)}return b}return null}function E(e){e=e.textNodeWithOffset;null==e&&w(82);return e}function F(e,c){c=E(c);return null===c.node.getPreviousSibling()?(c=c.node.getTextContent(),D(c,!0,!1,e.regExForAutoFormatting)):null}
-function G(e,c,f,a,b){var d=b.patternMatchResults;const g=d.regExCaptureGroups;var k=g.length;if(e>=k||c>=k)return null;b=E(b).node.getParentOrThrow();k=d.regExCaptureGroups.length;2>k?d=0:(--k,d=d.regExCaptureGroups[k].offsetInParent+d.regExCaptureGroups[k].text.length);e=g[e];c=g[c];a=a?c.offsetInParent+c.text.length:c.offsetInParent;f=u.$findNodeWithOffsetFromJoinedText(f?e.offsetInParent+e.text.length:e.offsetInParent,d,1,b);a=u.$findNodeWithOffsetFromJoinedText(a,d,1,b);if(null==f||null==a)return null;
-b=h.$createRangeSelection();b.anchor.set(f.node.getKey(),f.offset,"text");b.focus.set(a.node.getKey(),a.offset,"text");return b}function H(e,c,f){const a=f.patternMatchResults.regExCaptureGroups;f=G(e,c,!1,!0,f);if(null!=f&&(h.$setSelection(f),f=h.$getSelection(),null!=f&&h.$isRangeSelection(f)&&!1===f.isCollapsed())){f.removeText();f=0;const b=a.length;for(let d=e;d<b;d++){const g=a[d];d>e&&(g.offsetInParent-=f);d<=c&&(f+=g.text.length,g.text="")}}}
-function I(e){var c=e.patternMatchResults.regExCaptureGroups.length;2>c||(--c,e=G(c,c,!0,!0,e),null!=e&&h.$setSelection(e))}
-function J(e,c,f){e.update(()=>{if(!0===c.markdownCriteria.requiresParagraphStart){var a=E(c),b=a.node.getParentOrThrow();a=a.node.spliceText(0,c.patternMatchResults.regExCaptureGroups[0].text.length,"",!0);""===a.getTextContent()&&(a.selectPrevious(),a.remove());var d=b;a=null;var g=d.getChildren(),k=c.markdownCriteria;const l=c.patternMatchResults;if(null!=k.autoFormatKind)switch(k.autoFormatKind){case "paragraphH1":a=t.$createHeadingNode("h1");a.append(...g);break;case "paragraphH2":a=t.$createHeadingNode("h2");
-a.append(...g);break;case "paragraphH3":a=t.$createHeadingNode("h3");a.append(...g);break;case "paragraphBlockQuote":a=t.$createQuoteNode();a.append(...g);break;case "paragraphUnorderedList":a=p.$createListNode("ul");d=p.$createListItemNode();d.append(...g);a.append(d);break;case "paragraphOrderedList":a=parseInt(1<l.regExCaptureGroups.length?l.regExCaptureGroups[l.regExCaptureGroups.length-1].text:"1",10);a=p.$createListNode("ol",a);d=p.$createListItemNode();d.append(...g);a.append(d);break;case "paragraphCodeBlock":null!=
-c.triggerState&&c.triggerState.isCodeBlock?a=h.$createParagraphNode():(a=n.$createCodeNode(),d=3<=l.regExCaptureGroups.length?l.regExCaptureGroups[2].text:null,null!=d&&0<d.length&&a.setLanguage(d));a.append(...g);break;case "horizontalRule":g=f(),d.insertBefore(g)}null!==a&&b.replace(a)}else if(b=c.markdownCriteria,null!=b.autoFormatKind){a:{a=b.autoFormatKind;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(b=a,7===c.patternMatchResults.regExCaptureGroups.length){H(5,5,c);H(1,1,c);a=c.patternMatchResults.regExCaptureGroups;3<a.length||w(65);if(0!==a[3].text.length&&(a=G(3,3,!1,!0,c),null!=a&&(h.$setSelection(a),a=h.$getSelection(),h.$isRangeSelection(a))))for(g=0;g<b.length;g++)a.formatText(b[g]);I(c)}}else if("link"===b.autoFormatKind&&(b=c.patternMatchResults.regExCaptureGroups,7===b.length&&(g=b[2].text,b=b[4].text,0!==g.length&&0!==b.length))){H(1,5,c);a=c.patternMatchResults.regExCaptureGroups;
-if(!(1>=a.length)&&(g={offsetInParent:a[1].offsetInParent,text:g},d=G(1,1,!1,!1,c),null!=d&&(h.$setSelection(d),d=h.$getSelection(),null!=d&&h.$isRangeSelection(d)&&d.isCollapsed())))for(d.insertText(g.text),a.splice(1,0,g),g=g.text.length,d=a.length,k=2;k<d;k++)a[k].offsetInParent+=g;a=G(1,1,!1,!0,c);null!=a&&(h.$setSelection(a),c.editor.dispatchCommand(r.TOGGLE_LINK_COMMAND,b),I(c))}}},{tag:"history-push"})}
-function K(e,c){let f=null;e.getEditorState().read(()=>{var a=h.$getSelection();if(h.$isRangeSelection(a)){var b=a.anchor.getNode();a=h.$isTextNode(b)?{node:b,offset:a.anchor.offset}:null}else a=null;if(null!==a){a=C(e,!0,a,c);a:{b=!1===c.isParentAListItemNode?B:A;const k=a.triggerState,l=b.length;for(let m=0;m<l;m++){const v=b[m];if(null!=k&&!1===k.isCodeBlock||"paragraphCodeBlock"===v.autoFormatKind){var d=v,g=a;if(!0===d.requiresParagraphStart)d=F(d,g);else{if(null==g.joinedText){const q=E(g).node.getParentOrThrow();
-h.$isElementNode(q)?null==g.joinedText&&(g.joinedText=u.$joinTextNodesInElementNode(q,"\u0004",E(g))):w(52,q.__key)}d=D(g.joinedText,!1,!0,d.regExForAutoFormatting)}if(null!=d){b={markdownCriteria:v,patternMatchResults:d};break a}}}b={markdownCriteria:null,patternMatchResults:null}}null!==b.markdownCriteria&&null!==b.patternMatchResults&&(f=a,f.markdownCriteria=b.markdownCriteria,f.patternMatchResults=b.patternMatchResults)}});return f}
-function L(e){let c=null;e.read(()=>{const f=h.$getSelection();if(h.$isRangeSelection(f)&&f.isCollapsed()){var a=f.anchor.getNode(),b=a.getParent(),d=p.$isListItemNode(b);c={anchorOffset:f.anchor.offset,hasParentNode:null!==b,isCodeBlock:n.$isCodeNode(a),isParentAListItemNode:d,isSelectionCollapsed:!0,isSimpleText:h.$isTextNode(a)&&a.isSimpleText(),nodeKey:a.getKey(),textContent:a.getTextContent()}}});return c}
-function M(e){e=e.split("\n").map(f=>h.$createParagraphNode().append(h.$createTextNode(f)));const c=h.$getRoot();c.clear();c.append(...e)}
-exports.$convertFromMarkdownString=function(e,c){M(e);e=h.$getRoot().getChildren();c=C(c,!1,null,null);const f=e.length;for(let g=0;g<f;g++){var a=e[g];if(h.$isElementNode(a)&&a.getTextContent().length&&a.getChildren().length){var b=c;if(h.$isParagraphNode(a)){const k=B.length;for(let l=0;l<k;l++){const m=B[l];if(!0===m.requiresParagraphStart){var d=a.getFirstChild();h.$isTextNode(d)||w(80);b.textNodeWithOffset={node:d,offset:0};b.joinedText=a.getTextContent();d=F(m,b);null!=d&&(b.markdownCriteria=
-m,b.patternMatchResults=d)}}}}b=c;b.joinedText="";b.markdownCriteria={autoFormatKind:"noTransformation",regEx:/(?:)/,regExForAutoFormatting:/(?:)/,requiresParagraphStart:null};b.patternMatchResults={regExCaptureGroups:[]};b.triggerState=null;b.textNodeWithOffset=null}};
-exports.registerMarkdownShortcuts=function(e,c){let f=null;return e.registerUpdateListener(({tags:a})=>{if(!1===a.has("historic")){a=L(e.getEditorState());if(null==a)var b=null;else a:{b=a;var d=f;if(null==b||null==d)b=null;else{var g=x.length;for(let k=0;k<g;k++){const l=x[k].triggerString,m=l.length,v=b.textContent.length,q=b.anchorOffset-m;if(!1===(!0===b.hasParentNode&&b.isSimpleText&&b.isSelectionCollapsed&&b.nodeKey===d.nodeKey&&b.anchorOffset!==d.anchorOffset&&0<=q&&q+m<=v&&b.textContent.substr(q,
-m)===l&&b.textContent!==d.textContent)){b=null;break a}}b=K(e,b)}}null!=b&&J(e,b,c);f=a}else f=null})};
+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})};

package/package.json

@@ -8,18 +8,18 @@
     "markdown"
   ],
   "license": "MIT",
-  "version": "0.1.19",
+  "version": "0.2.0",
   "main": "LexicalMarkdown.js",
   "peerDependencies": {
-    "lexical": "0.1.19"
+    "lexical": "0.2.0"
   },
   "dependencies": {
-    "@lexical/utils": "0.1.19",
-    "@lexical/code": "0.1.19",
-    "@lexical/text": "0.1.19",
-    "@lexical/rich-text": "0.1.19",
-    "@lexical/list": "0.1.19",
-    "@lexical/link": "0.1.19"
+    "@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"
   },
   "repository": {
     "type": "git",