@lexical/markdown 0.1.18 → 0.1.21

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.
@@ -52,7 +52,7 @@ const triggers = [spaceTrigger
 ]; // Todo: speed up performance by having non-capture group variations of the regex.
 
 const autoFormatBase = {
-  autoFormatKind: null,
+  markdownFormatKind: null,
   regEx: /(?:)/,
   regExForAutoFormatting: /(?:)/,
   requiresParagraphStart: false
@@ -61,89 +61,89 @@ const paragraphStartBase = { ...autoFormatBase,
   requiresParagraphStart: true
 };
 const markdownHeader1 = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphH1',
+  markdownFormatKind: 'paragraphH1',
   regEx: /^(?:#)/,
   regExForAutoFormatting: /^(?:# )/
 };
 const markdownHeader2 = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphH2',
+  markdownFormatKind: 'paragraphH2',
   regEx: /^(?:##)/,
   regExForAutoFormatting: /^(?:## )/
 };
 const markdownHeader3 = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphH2',
+  markdownFormatKind: 'paragraphH2',
   regEx: /^(?:###)/,
   regExForAutoFormatting: /^(?:### )/
 };
 const markdownBlockQuote = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphBlockQuote',
+  markdownFormatKind: 'paragraphBlockQuote',
   regEx: /^(?:>)/,
   regExForAutoFormatting: /^(?:> )/
 };
 const markdownUnorderedListDash = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphUnorderedList',
+  markdownFormatKind: 'paragraphUnorderedList',
   regEx: /^(?:- )/,
   regExForAutoFormatting: /^(?:- )/
 };
 const markdownUnorderedListAsterisk = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphUnorderedList',
+  markdownFormatKind: 'paragraphUnorderedList',
   regEx: /^(?:\* )/,
   regExForAutoFormatting: /^(?:\* )/
 };
 const markdownCodeBlock = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphCodeBlock',
+  markdownFormatKind: 'paragraphCodeBlock',
   regEx: /^(```)$/,
   regExForAutoFormatting: /^(```)([a-z]*)( )/
 };
 const markdownOrderedList = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphOrderedList',
+  markdownFormatKind: 'paragraphOrderedList',
   regEx: /^(\d+)\.\s/,
   regExForAutoFormatting: /^(\d+)\.\s/
 };
 const markdownHorizontalRule = { ...paragraphStartBase,
-  autoFormatKind: 'horizontalRule',
+  markdownFormatKind: 'horizontalRule',
   regEx: /^(?:\*\*\*)$/,
   regExForAutoFormatting: /^(?:\*\*\* )/
 };
 const markdownHorizontalRuleUsingDashes = { ...paragraphStartBase,
-  autoFormatKind: 'horizontalRule',
+  markdownFormatKind: 'horizontalRule',
   regEx: /^(?:---)$/,
   regExForAutoFormatting: /^(?:--- )/
 };
 const markdownItalic = { ...autoFormatBase,
-  autoFormatKind: 'italic',
+  markdownFormatKind: 'italic',
   regEx: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*)/,
   regExForAutoFormatting: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*)(\s)$/
 };
 const markdownBold = { ...autoFormatBase,
-  autoFormatKind: 'bold',
+  markdownFormatKind: 'bold',
   regEx: /(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)/,
   regExForAutoFormatting: /(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)(\s)$/
 };
 const markdownBoldWithUnderlines = { ...autoFormatBase,
-  autoFormatKind: 'bold',
+  markdownFormatKind: 'bold',
   regEx: /(__)(\s*)([^__]*)(\s*)(__)/,
   regExForAutoFormatting: /(__)(\s*)([^__]*)(\s*)(__)(\s)$/
 };
 const markdownBoldItalic = { ...autoFormatBase,
-  autoFormatKind: 'bold_italic',
+  markdownFormatKind: 'bold_italic',
   regEx: /(\*\*\*)(\s*\b)([^\*\*\*]*)(\b\s*)(\*\*\*)/,
   regExForAutoFormatting: /(\*\*\*)(\s*\b)([^\*\*\*]*)(\b\s*)(\*\*\*)(\s)$/
 }; // 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',
+  markdownFormatKind: 'strikethrough',
   regEx: /(~~)(\s*\b)([^~~]*)(\b\s*)(~~)/,
   regExForAutoFormatting: /(~~)(\s*\b)([^~~]*)(\b\s*)(~~)(\s)$/
 };
 const markdownLink = { ...autoFormatBase,
-  autoFormatKind: 'link',
+  markdownFormatKind: 'link',
   regEx: /(\[)(.+)(\]\()([^ ]+)(?: \"(?:.+)\")?(\))/,
   regExForAutoFormatting: /(\[)(.+)(\]\()([^ ]+)(?: \"(?:.+)\")?(\))(\s)$/
 };
@@ -151,11 +151,13 @@ const allMarkdownCriteriaForTextNodes = [markdownBoldItalic, markdownItalic, mar
 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 +174,7 @@ function getInitialScanningContext(editor, isAutoFormatting, textNodeWithOffset,
 function resetScanningContext(scanningContext) {
   scanningContext.joinedText = '';
   scanningContext.markdownCriteria = {
-    autoFormatKind: 'noTransformation',
+    markdownFormatKind: 'noTransformation',
     regEx: /(?:)/,
     // Empty reg ex.
     regExForAutoFormatting: /(?:)/,
@@ -186,6 +188,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 = {
@@ -233,7 +242,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,38 +268,51 @@ 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':
@@ -299,7 +321,10 @@ function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNod
           const listItem = list.$createListItemNode();
           listItem.append(...children);
           newNode.append(listItem);
-          return newNode;
+          return {
+            newNode,
+            shouldDelete
+          };
         }
 
       case 'paragraphOrderedList':
@@ -310,12 +335,55 @@ function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNod
           const listItem = list.$createListItemNode();
           listItem.append(...children);
           newNode.append(listItem);
-          return newNode;
+          return {
+            newNode,
+            shouldDelete
+          };
         }
 
       case 'paragraphCodeBlock':
         {
           // Toggle code and paragraph nodes.
+          if (scanningContext.isAutoFormatting === false) {
+            const shouldToggle = scanningContext.patternMatchResults.regExCaptureGroups.length > 0;
+
+            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);
+                codeBlockNode.append(...children);
+              }
+            }
+
+            return {
+              newNode: null,
+              shouldDelete: true
+            };
+          }
+
           if (scanningContext.triggerState != null && scanningContext.triggerState.isCodeBlock) {
             newNode = lexical.$createParagraphNode();
           } else {
@@ -328,53 +396,70 @@ 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.
 
-  const textNode = textNodeWithOffset.node.spliceText(0, text.length, '', true);
+  if (scanningContext.patternMatchResults.regExCaptureGroups.length > 0) {
+    const text = scanningContext.patternMatchResults.regExCaptureGroups[0].text; // Remove the text which we matched.
 
-  if (textNode.getTextContent() === '') {
-    textNode.selectPrevious();
-    textNode.remove();
+    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.
 
 
-  const elementNode = getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNode);
+  const {
+    newNode,
+    shouldDelete
+  } = getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNode);
 
-  if (elementNode !== null) {
-    element.replace(elementNode);
+  if (shouldDelete) {
+    element.remove();
+  } else if (newNode !== null) {
+    element.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,13 +551,13 @@ 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];
+      return [markdownFormatKind];
 
     case 'bold_italic':
       {
@@ -689,7 +774,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 +861,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,17 +879,62 @@ 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;
+  }
+
+  const nodes = [];
+  const splitLines = text.split('\n');
+  const splitLinesCount = splitLines.length;
+
+  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 (nodes.length) {
+    const root = lexical.$getRoot();
+    root.clear();
+    root.append(...nodes);
+    return root;
+  }
+
+  return null;
 }
 
-function convertElementNodeContainingMarkdown(scanningContext, elementNode) {
-  // Handle code block to be done.
-  // Handle paragraph nodes below.
-  if (lexical.$isParagraphNode(elementNode)) {
+function convertElementNodeContainingMarkdown(scanningContext, elementNode, createHorizontalRuleNode) {
+  const textContent = elementNode.getTextContent(); // Handle paragraph nodes below.
+
+  if (lexical.$isParagraphNode(elementNode) && elementNode.getChildren().length) {
     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 (patternMatchResults != null) {
+        // Toggle transform to or from code block.
+        scanningContext.patternMatchResults = patternMatchResults;
+      }
+
+      scanningContext.markdownCriteria = getCodeBlockCriteria(); // Perform text transformation here.
+
+      transformTextNodeForParagraphs(scanningContext, createHorizontalRuleNode);
+      return;
+    }
+
     const allCriteria = getAllMarkdownCriteria();
     const count = allCriteria.length;
 
@@ -812,9 +942,7 @@ function convertElementNodeContainingMarkdown(scanningContext, elementNode) {
       const criteria = allCriteria[i];
 
       if (criteria.requiresParagraphStart === true) {
-        const firstChild = paragraphNode.getFirstChild();
-
-        if (!lexical.$isTextNode(firstChild)) {
+        if (!(firstChild != null && firstChildIsTextNode)) {
           throw Error(`Expect paragraph containing only text nodes.`);
         }
 
@@ -828,28 +956,47 @@ function convertElementNodeContainingMarkdown(scanningContext, elementNode) {
         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.
+          scanningContext.patternMatchResults = patternMatchResults; // Perform text transformation here.
+
+          transformTextNodeForParagraphs(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 +1032,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,29 @@
  * 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"),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})};

package/package.json

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