@lexical/markdown 0.1.21 → 0.2.0

package/LexicalMarkdown.dev.js

@@ -41,7 +41,7 @@ const SEPARATOR_LENGTH = SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES.length;
 const spaceTrigger = {
   triggerKind: 'space_trigger',
   triggerString: '\u0020'
-}; // TODO: add support for ``` + carriage return either inside or not inside code block. Should toggle between.
+}; // Future todo: add support for ``` + carriage return either inside or not inside code block. Should toggle between.
 // const codeBlockTrigger : AutoFormatTrigger = {
 //     triggerKind: 'codeBlock_trigger',
 //     triggerString: '```', // + new paragraph element or new code block element.
@@ -49,7 +49,7 @@ const spaceTrigger = {
 
 const triggers = [spaceTrigger
 /*, codeBlockTrigger*/
-]; // Todo: speed up performance by having non-capture group variations of the regex.
+]; // Future Todo: speed up performance by having non-capture group variations of the regex.
 
 const autoFormatBase = {
   markdownFormatKind: null,
@@ -62,33 +62,33 @@ const paragraphStartBase = { ...autoFormatBase,
 };
 const markdownHeader1 = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphH1',
-  regEx: /^(?:#)/,
+  regEx: /^(?:# )/,
   regExForAutoFormatting: /^(?:# )/
 };
 const markdownHeader2 = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphH2',
-  regEx: /^(?:##)/,
+  regEx: /^(?:## )/,
   regExForAutoFormatting: /^(?:## )/
 };
 const markdownHeader3 = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphH2',
-  regEx: /^(?:###)/,
+  regEx: /^(?:### )/,
   regExForAutoFormatting: /^(?:### )/
 };
 const markdownBlockQuote = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphBlockQuote',
-  regEx: /^(?:>)/,
+  regEx: /^(?:> )/,
   regExForAutoFormatting: /^(?:> )/
 };
 const markdownUnorderedListDash = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphUnorderedList',
-  regEx: /^(?:- )/,
-  regExForAutoFormatting: /^(?:- )/
+  regEx: /^(\s{0,10})(?:- )/,
+  regExForAutoFormatting: /^(\s{0,10})(?:- )/
 };
 const markdownUnorderedListAsterisk = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphUnorderedList',
-  regEx: /^(?:\* )/,
-  regExForAutoFormatting: /^(?:\* )/
+  regEx: /^(\s{0,10})(?:\* )/,
+  regExForAutoFormatting: /^(\s{0,10})(?:\* )/
 };
 const markdownCodeBlock = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphCodeBlock',
@@ -97,8 +97,8 @@ const markdownCodeBlock = { ...paragraphStartBase,
 };
 const markdownOrderedList = { ...paragraphStartBase,
   markdownFormatKind: 'paragraphOrderedList',
-  regEx: /^(\d+)\.\s/,
-  regExForAutoFormatting: /^(\d+)\.\s/
+  regEx: /^(\s{0,10})(\d+)\.\s/,
+  regExForAutoFormatting: /^(\s{0,10})(\d+)\.\s/
 };
 const markdownHorizontalRule = { ...paragraphStartBase,
   markdownFormatKind: 'horizontalRule',
@@ -110,25 +110,31 @@ const markdownHorizontalRuleUsingDashes = { ...paragraphStartBase,
   regEx: /^(?:---)$/,
   regExForAutoFormatting: /^(?:--- )/
 };
+const markdownInlineCode = { ...autoFormatBase,
+  markdownFormatKind: 'code',
+  regEx: /(`)([^`]*)(`)/,
+  regExForAutoFormatting: /(`)(\s*\b)([^`]*)(\b\s*)(`)(\s)$/
+};
 const markdownItalic = { ...autoFormatBase,
   markdownFormatKind: 'italic',
-  regEx: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*)/,
+  regEx: /(\*)([^\*]*)(\*)/,
   regExForAutoFormatting: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*)(\s)$/
 };
 const markdownBold = { ...autoFormatBase,
   markdownFormatKind: 'bold',
-  regEx: /(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)/,
+  regEx: /(\*\*)([^\*\*]*)(\*\*)/,
   regExForAutoFormatting: /(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)(\s)$/
 };
-const markdownBoldWithUnderlines = { ...autoFormatBase,
+const markdownBold2 = { ...autoFormatBase,
   markdownFormatKind: 'bold',
   regEx: /(__)(\s*)([^__]*)(\s*)(__)/,
   regExForAutoFormatting: /(__)(\s*)([^__]*)(\s*)(__)(\s)$/
 };
-const markdownBoldItalic = { ...autoFormatBase,
-  markdownFormatKind: 'bold_italic',
-  regEx: /(\*\*\*)(\s*\b)([^\*\*\*]*)(\b\s*)(\*\*\*)/,
-  regExForAutoFormatting: /(\*\*\*)(\s*\b)([^\*\*\*]*)(\b\s*)(\*\*\*)(\s)$/
+const markdownItalic2 = { ...autoFormatBase,
+  markdownFormatKind: 'italic',
+  regEx: /(_)([^_]*)(_)/,
+  regExForAutoFormatting: /(_)()([^_]*)()(_)(\s)$/ // Maintain 7 groups.
+
 }; // Markdown does not support underline, but we can allow folks to use
 // the HTML tags for underline.
 
@@ -139,15 +145,39 @@ const fakeMarkdownUnderline = { ...autoFormatBase,
 };
 const markdownStrikethrough = { ...autoFormatBase,
   markdownFormatKind: 'strikethrough',
-  regEx: /(~~)(\s*\b)([^~~]*)(\b\s*)(~~)/,
+  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,
   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 {
@@ -226,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;
 
@@ -317,27 +350,24 @@ function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNod
 
       case 'paragraphUnorderedList':
         {
-          newNode = list.$createListNode('ul');
-          const listItem = list.$createListItemNode();
-          listItem.append(...children);
-          newNode.append(listItem);
+          createListOrMergeWithPrevious(element, children, patternMatchResults, 'ul');
           return {
-            newNode,
-            shouldDelete
+            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);
+          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,
-            shouldDelete
+            newNode: null,
+            shouldDelete: false
           };
         }
 
@@ -345,7 +375,7 @@ function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNod
         {
           // Toggle code and paragraph nodes.
           if (scanningContext.isAutoFormatting === false) {
-            const shouldToggle = scanningContext.patternMatchResults.regExCaptureGroups.length > 0;
+            const shouldToggle = hasPatternMatchResults(scanningContext);
 
             if (shouldToggle) {
               scanningContext.isWithinCodeBlock = scanningContext.isWithinCodeBlock !== true; // When toggling, always clear the code block element node.
@@ -374,6 +404,11 @@ function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNod
                 const codeBlockNode = scanningContext.currentElementNode;
                 const lineBreakNode = lexical.$createLineBreakNode();
                 codeBlockNode.append(lineBreakNode);
+
+                if (children.length) {
+                  codeBlockNode.append(lineBreakNode);
+                }
+
                 codeBlockNode.append(...children);
               }
             }
@@ -421,18 +456,42 @@ function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNod
   };
 }
 
-function transformTextNodeForParagraphs(scanningContext, createHorizontalRuleNode) {
-  const textNodeWithOffset = getTextNodeWithOffsetOrThrow(scanningContext);
-  const element = textNodeWithOffset.node.getParentOrThrow();
+function createListOrMergeWithPrevious(element, children, patternMatchResults, tag, start) {
+  const listItem = list.$createListItemNode();
+  const indentMatch = patternMatchResults.regExCaptureGroups[0].text.match(/^\s*/);
+  const indent = indentMatch ? Math.floor(indentMatch[0].length / 4) : 0;
+  listItem.append(...children); // Checking if previous element is a list, and if so append
+  // new list item inside instead of creating new list
 
-  if (scanningContext.patternMatchResults.regExCaptureGroups.length > 0) {
-    const text = scanningContext.patternMatchResults.regExCaptureGroups[0].text; // Remove the text which we matched.
+  const prevElement = element.getPreviousSibling();
 
-    const textNode = textNodeWithOffset.node.spliceText(0, text.length, '', true);
+  if (list.$isListNode(prevElement) && prevElement.getTag() === tag) {
+    prevElement.append(listItem);
+    element.remove();
+  } else {
+    const list$1 = list.$createListNode(tag, start);
+    list$1.append(listItem);
+    element.replace(list$1);
+  }
+
+  if (indent) {
+    listItem.setIndent(indent);
+  }
+}
 
-    if (textNode.getTextContent() === '') {
-      textNode.selectPrevious();
-      textNode.remove();
+function transformTextNodeForElementNode(elementNode, scanningContext, createHorizontalRuleNode) {
+  if (scanningContext.textNodeWithOffset != null) {
+    const textNodeWithOffset = getTextNodeWithOffsetOrThrow(scanningContext);
+
+    if (hasPatternMatchResults(scanningContext)) {
+      const text = scanningContext.patternMatchResults.regExCaptureGroups[0].text; // Remove the text which we matched.
+
+      const textNode = textNodeWithOffset.node.spliceText(0, text.length, '', true);
+
+      if (textNode.getTextContent() === '') {
+        textNode.selectPrevious();
+        textNode.remove();
+      }
     }
   } // Transform the current element kind to the new element kind.
 
@@ -440,12 +499,12 @@ function transformTextNodeForParagraphs(scanningContext, createHorizontalRuleNod
   const {
     newNode,
     shouldDelete
-  } = getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNode);
+  } = getNewNodeForCriteria(scanningContext, elementNode, createHorizontalRuleNode);
 
   if (shouldDelete) {
-    element.remove();
+    elementNode.remove();
   } else if (newNode !== null) {
-    element.replace(newNode);
+    elementNode.replace(newNode);
   }
 }
 function transformTextNodeForText(scanningContext) {
@@ -557,11 +616,27 @@ function getTextFormatType(markdownFormatKind) {
     case 'bold':
     case 'underline':
     case 'strikethrough':
+    case 'code':
       return [markdownFormatKind];
 
-    case 'bold_italic':
+    case 'strikethrough_italic_bold':
       {
-        return ['bold', 'italic'];
+        return ['strikethrough', 'italic', 'bold'];
+      }
+
+    case 'italic_bold':
+      {
+        return ['italic', 'bold'];
+      }
+
+    case 'strikethrough_italic':
+      {
+        return ['strikethrough', 'italic'];
+      }
+
+    case 'strikethrough_bold':
+      {
+        return ['strikethrough', 'bold'];
       }
   }
 
@@ -728,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);
   }
@@ -908,58 +984,59 @@ function convertStringToLexical(text, editor) {
 function convertElementNodeContainingMarkdown(scanningContext, elementNode, createHorizontalRuleNode) {
   const textContent = elementNode.getTextContent(); // Handle paragraph nodes below.
 
-  if (lexical.$isParagraphNode(elementNode) && elementNode.getChildren().length) {
+  if (lexical.$isParagraphNode(elementNode)) {
     const paragraphNode = elementNode;
     const firstChild = paragraphNode.getFirstChild();
     const firstChildIsTextNode = lexical.$isTextNode(firstChild); // Handle conversion to code block.
 
     if (scanningContext.isWithinCodeBlock === true) {
-      if (!(firstChild != null && firstChildIsTextNode)) {
-        throw Error(`Expect paragraph containing only text nodes.`);
-      }
-
-      scanningContext.textNodeWithOffset = {
-        node: firstChild,
-        offset: 0
-      };
-      const patternMatchResults = getPatternMatchResultsForCodeBlock(scanningContext, textContent);
+      if (firstChild != null && firstChildIsTextNode) {
+        // Test if we encounter ending code block.
+        scanningContext.textNodeWithOffset = {
+          node: firstChild,
+          offset: 0
+        };
+        const patternMatchResults = getPatternMatchResultsForCodeBlock(scanningContext, textContent);
 
-      if (patternMatchResults != null) {
-        // Toggle transform to or from code block.
-        scanningContext.patternMatchResults = patternMatchResults;
+        if (patternMatchResults != null) {
+          // Toggle transform to or from code block.
+          scanningContext.patternMatchResults = patternMatchResults;
+        }
       }
 
       scanningContext.markdownCriteria = getCodeBlockCriteria(); // Perform text transformation here.
 
-      transformTextNodeForParagraphs(scanningContext, createHorizontalRuleNode);
+      transformTextNodeForElementNode(elementNode, scanningContext, createHorizontalRuleNode);
       return;
     }
 
-    const allCriteria = getAllMarkdownCriteria();
-    const count = allCriteria.length;
+    if (elementNode.getChildren().length) {
+      const allCriteria = getAllMarkdownCriteria();
+      const count = allCriteria.length;
 
-    for (let i = 0; i < count; i++) {
-      const criteria = allCriteria[i];
+      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 === 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);
+          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.
+          if (patternMatchResults != null) {
+            // Lazy fill-in the particular format criteria and any matching result information.
+            scanningContext.markdownCriteria = criteria;
+            scanningContext.patternMatchResults = patternMatchResults; // Perform text transformation here.
 
-          transformTextNodeForParagraphs(scanningContext, createHorizontalRuleNode);
-          return;
+            transformTextNodeForElementNode(elementNode, scanningContext, createHorizontalRuleNode);
+            return;
+          }
         }
       }
     }

package/LexicalMarkdown.prod.js

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