@lexical/markdown 0.12.1 → 0.12.3

package/LexicalMarkdown.dev.js

@@ -20,20 +20,16 @@ var link = require('@lexical/link');
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 function indexBy(list, callback) {
   const index = {};
-
   for (const item of list) {
     const key = callback(item);
-
     if (index[key]) {
       index[key].push(item);
     } else {
       index[key] = [item];
     }
   }
-
   return index;
 }
 function transformersByType(transformers) {
@@ -54,35 +50,30 @@ const PUNCTUATION_OR_SPACE = /[!-/:-@[-`{-~\s]/;
  *
  */
 function createMarkdownExport(transformers) {
-  const byType = transformersByType(transformers); // Export only uses text formats that are responsible for single format
-  // e.g. it will filter out *** (bold, italic) and instead use separate ** and *
+  const byType = transformersByType(transformers);
 
+  // Export only uses text formats that are responsible for single format
+  // e.g. it will filter out *** (bold, italic) and instead use separate ** and *
   const textFormatTransformers = byType.textFormat.filter(transformer => transformer.format.length === 1);
   return node => {
     const output = [];
     const children = (node || lexical.$getRoot()).getChildren();
-
     for (const child of children) {
       const result = exportTopLevelElements(child, byType.element, textFormatTransformers, byType.textMatch);
-
       if (result != null) {
         output.push(result);
       }
     }
-
     return output.join('\n\n');
   };
 }
-
 function exportTopLevelElements(node, elementTransformers, textTransformersIndex, textMatchTransformers) {
   for (const transformer of elementTransformers) {
     const result = transformer.export(node, _node => exportChildren(_node, textTransformersIndex, textMatchTransformers));
-
     if (result != null) {
       return result;
     }
   }
-
   if (lexical.$isElementNode(node)) {
     return exportChildren(node, textTransformersIndex, textMatchTransformers);
   } else if (lexical.$isDecoratorNode(node)) {
@@ -91,21 +82,17 @@ function exportTopLevelElements(node, elementTransformers, textTransformersIndex
     return null;
   }
 }
-
 function exportChildren(node, textTransformersIndex, textMatchTransformers) {
   const output = [];
   const children = node.getChildren();
-
   mainLoop: for (const child of children) {
     for (const transformer of textMatchTransformers) {
       const result = transformer.export(child, parentNode => exportChildren(parentNode, textTransformersIndex, textMatchTransformers), (textNode, textContent) => exportTextFormat(textNode, textContent, textTransformersIndex));
-
       if (result != null) {
         output.push(result);
         continue mainLoop;
       }
     }
-
     if (lexical.$isLineBreakNode(child)) {
       output.push('\n');
     } else if (lexical.$isTextNode(child)) {
@@ -116,10 +103,8 @@ function exportChildren(node, textTransformersIndex, textMatchTransformers) {
       output.push(child.getTextContent());
     }
   }
-
   return output.join('');
 }
-
 function exportTextFormat(node, textContent, textTransformers) {
   // This function handles the case of a string looking like this: "   foo   "
   // Where it would be invalid markdown to generate: "**   foo   **"
@@ -128,74 +113,61 @@ function exportTextFormat(node, textContent, textTransformers) {
   const frozenString = textContent.trim();
   let output = frozenString;
   const applied = new Set();
-
   for (const transformer of textTransformers) {
     const format = transformer.format[0];
     const tag = transformer.tag;
-
     if (hasFormat(node, format) && !applied.has(format)) {
       // Multiple tags might be used for the same format (*, _)
-      applied.add(format); // Prevent adding opening tag is already opened by the previous sibling
-
+      applied.add(format);
+      // Prevent adding opening tag is already opened by the previous sibling
       const previousNode = getTextSibling(node, true);
-
       if (!hasFormat(previousNode, format)) {
         output = tag + output;
-      } // Prevent adding closing tag if next sibling will do it
-
+      }
 
+      // Prevent adding closing tag if next sibling will do it
       const nextNode = getTextSibling(node, false);
-
       if (!hasFormat(nextNode, format)) {
         output += tag;
       }
     }
-  } // Replace trimmed version of textContent ensuring surrounding whitespace is not modified
-
+  }
 
+  // Replace trimmed version of textContent ensuring surrounding whitespace is not modified
   return textContent.replace(frozenString, output);
-} // Get next or previous text sibling a text node, including cases
-// when it's a child of inline element (e.g. link)
-
+}
 
+// Get next or previous text sibling a text node, including cases
+// when it's a child of inline element (e.g. link)
 function getTextSibling(node, backward) {
   let sibling = backward ? node.getPreviousSibling() : node.getNextSibling();
-
   if (!sibling) {
     const parent = node.getParentOrThrow();
-
     if (parent.isInline()) {
       sibling = backward ? parent.getPreviousSibling() : parent.getNextSibling();
     }
   }
-
   while (sibling) {
     if (lexical.$isElementNode(sibling)) {
       if (!sibling.isInline()) {
         break;
       }
-
       const descendant = backward ? sibling.getLastDescendant() : sibling.getFirstDescendant();
-
       if (lexical.$isTextNode(descendant)) {
         return descendant;
       } else {
         sibling = backward ? sibling.getPreviousSibling() : sibling.getNextSibling();
       }
     }
-
     if (lexical.$isTextNode(sibling)) {
       return sibling;
     }
-
     if (!lexical.$isElementNode(sibling)) {
       return null;
     }
   }
-
   return null;
 }
-
 function hasFormat(node, format) {
   return lexical.$isTextNode(node) && node.hasFormat(format);
 }
@@ -207,6 +179,7 @@ function hasFormat(node, format) {
  * LICENSE file in the root directory of this source tree.
  *
  */
+
 const CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
 
 /**
@@ -221,10 +194,13 @@ CAN_USE_DOM && /Mac|iPod|iPhone|iPad/.test(navigator.platform);
 CAN_USE_DOM && /^(?!.*Seamonkey)(?=.*Firefox).*/i.test(navigator.userAgent);
 CAN_USE_DOM && 'InputEvent' in window && !documentMode ? 'getTargetRanges' in new window.InputEvent('input') : false;
 const IS_SAFARI = CAN_USE_DOM && /Version\/[\d.]+.*Safari/.test(navigator.userAgent);
-const IS_IOS = CAN_USE_DOM && /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream; // Keep these in case we need to use them in the future.
-// export const IS_WINDOWS: boolean = CAN_USE_DOM && /Win/.test(navigator.platform);
+const IS_IOS = CAN_USE_DOM && /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
+CAN_USE_DOM && /Android/.test(navigator.userAgent);
 
-const IS_CHROME = CAN_USE_DOM && /^(?=.*Chrome).*/i.test(navigator.userAgent); // export const canUseTextInputEvent: boolean = CAN_USE_DOM && 'TextEvent' in window && !documentMode;
+// Keep these in case we need to use them in the future.
+// export const IS_WINDOWS: boolean = CAN_USE_DOM && /Win/.test(navigator.platform);
+const IS_CHROME = CAN_USE_DOM && /^(?=.*Chrome).*/i.test(navigator.userAgent);
+// export const canUseTextInputEvent: boolean = CAN_USE_DOM && 'TextEvent' in window && !documentMode;
 
 const IS_APPLE_WEBKIT = CAN_USE_DOM && /AppleWebKit\/[\d.]+/.test(navigator.userAgent) && !IS_CHROME;
 
@@ -245,88 +221,74 @@ function createMarkdownImport(transformers) {
     const linesLength = lines.length;
     const root = node || lexical.$getRoot();
     root.clear();
-
     for (let i = 0; i < linesLength; i++) {
-      const lineText = lines[i]; // Codeblocks are processed first as anything inside such block
+      const lineText = lines[i];
+      // Codeblocks are processed first as anything inside such block
       // is ignored for further processing
       // TODO:
       // Abstract it to be dynamic as other transformers (add multiline match option)
-
       const [codeBlockNode, shiftedIndex] = importCodeBlock(lines, i, root);
-
       if (codeBlockNode != null) {
         i = shiftedIndex;
         continue;
       }
-
       importBlocks(lineText, root, byType.element, textFormatTransformersIndex, byType.textMatch);
-    } // Removing empty paragraphs as md does not really
-    // allow empty lines and uses them as dilimiter
-
+    }
 
+    // Removing empty paragraphs as md does not really
+    // allow empty lines and uses them as dilimiter
     const children = root.getChildren();
-
     for (const child of children) {
       if (isEmptyParagraph(child)) {
         child.remove();
       }
     }
-
     if (lexical.$getSelection() !== null) {
       root.selectEnd();
     }
   };
 }
-
 function isEmptyParagraph(node) {
   if (!lexical.$isParagraphNode(node)) {
     return false;
   }
-
   const firstChild = node.getFirstChild();
   return firstChild == null || node.getChildrenSize() === 1 && lexical.$isTextNode(firstChild) && MARKDOWN_EMPTY_LINE_REG_EXP.test(firstChild.getTextContent());
 }
-
 function importBlocks(lineText, rootNode, elementTransformers, textFormatTransformersIndex, textMatchTransformers) {
   const lineTextTrimmed = lineText.trim();
   const textNode = lexical.$createTextNode(lineTextTrimmed);
   const elementNode = lexical.$createParagraphNode();
   elementNode.append(textNode);
   rootNode.append(elementNode);
-
   for (const {
     regExp,
     replace
   } of elementTransformers) {
     const match = lineText.match(regExp);
-
     if (match) {
       textNode.setTextContent(lineText.slice(match[0].length));
       replace(elementNode, [textNode], match, true);
       break;
     }
   }
+  importTextFormatTransformers(textNode, textFormatTransformersIndex, textMatchTransformers);
 
-  importTextFormatTransformers(textNode, textFormatTransformersIndex, textMatchTransformers); // If no transformer found and we left with original paragraph node
+  // If no transformer found and we left with original paragraph node
   // can check if its content can be appended to the previous node
   // if it's a paragraph, quote or list
-
   if (elementNode.isAttached() && lineTextTrimmed.length > 0) {
     const previousNode = elementNode.getPreviousSibling();
-
     if (lexical.$isParagraphNode(previousNode) || richText.$isQuoteNode(previousNode) || list.$isListNode(previousNode)) {
       let targetNode = previousNode;
-
       if (list.$isListNode(previousNode)) {
         const lastDescendant = previousNode.getLastDescendant();
-
         if (lastDescendant == null) {
           targetNode = null;
         } else {
           targetNode = utils.$findMatchingParent(lastDescendant, list.$isListItemNode);
         }
       }
-
       if (targetNode != null && targetNode.getTextContentSize() > 0) {
         targetNode.splice(targetNode.getChildrenSize(), 0, [lexical.$createLineBreakNode(), ...elementNode.getChildren()]);
         elementNode.remove();
@@ -334,17 +296,13 @@ function importBlocks(lineText, rootNode, elementTransformers, textFormatTransfo
     }
   }
 }
-
 function importCodeBlock(lines, startLineIndex, rootNode) {
   const openMatch = lines[startLineIndex].match(CODE_BLOCK_REG_EXP);
-
   if (openMatch) {
     let endLineIndex = startLineIndex;
     const linesLength = lines.length;
-
     while (++endLineIndex < linesLength) {
       const closeMatch = lines[endLineIndex].match(CODE_BLOCK_REG_EXP);
-
       if (closeMatch) {
         const codeBlockNode = code.$createCodeNode(openMatch[1]);
         const textNode = lexical.$createTextNode(lines.slice(startLineIndex + 1, endLineIndex).join('\n'));
@@ -354,157 +312,133 @@ function importCodeBlock(lines, startLineIndex, rootNode) {
       }
     }
   }
-
   return [null, startLineIndex];
-} // Processing text content and replaces text format tags.
+}
+
+// Processing text content and replaces text format tags.
 // It takes outermost tag match and its content, creates text node with
 // format based on tag and then recursively executed over node's content
 //
 // E.g. for "*Hello **world**!*" string it will create text node with
 // "Hello **world**!" content and italic format and run recursively over
 // its content to transform "**world**" part
-
-
 function importTextFormatTransformers(textNode, textFormatTransformersIndex, textMatchTransformers) {
   const textContent = textNode.getTextContent();
   const match = findOutermostMatch(textContent, textFormatTransformersIndex);
-
   if (!match) {
     // Once text format processing is done run text match transformers, as it
     // only can span within single text node (unline formats that can cover multiple nodes)
     importTextMatchTransformers(textNode, textMatchTransformers);
     return;
   }
+  let currentNode, remainderNode, leadingNode;
 
-  let currentNode, remainderNode, leadingNode; // If matching full content there's no need to run splitText and can reuse existing textNode
+  // If matching full content there's no need to run splitText and can reuse existing textNode
   // to update its content and apply format. E.g. for **_Hello_** string after applying bold
   // format (**) it will reuse the same text node to apply italic (_)
-
   if (match[0] === textContent) {
     currentNode = textNode;
   } else {
     const startIndex = match.index || 0;
     const endIndex = startIndex + match[0].length;
-
     if (startIndex === 0) {
       [currentNode, remainderNode] = textNode.splitText(endIndex);
     } else {
       [leadingNode, currentNode, remainderNode] = textNode.splitText(startIndex, endIndex);
     }
   }
-
   currentNode.setTextContent(match[2]);
   const transformer = textFormatTransformersIndex.transformersByTag[match[1]];
-
   if (transformer) {
     for (const format of transformer.format) {
       if (!currentNode.hasFormat(format)) {
         currentNode.toggleFormat(format);
       }
     }
-  } // Recursively run over inner text if it's not inline code
-
+  }
 
+  // Recursively run over inner text if it's not inline code
   if (!currentNode.hasFormat('code')) {
     importTextFormatTransformers(currentNode, textFormatTransformersIndex, textMatchTransformers);
-  } // Run over leading/remaining text if any
-
+  }
 
+  // Run over leading/remaining text if any
   if (leadingNode) {
     importTextFormatTransformers(leadingNode, textFormatTransformersIndex, textMatchTransformers);
   }
-
   if (remainderNode) {
     importTextFormatTransformers(remainderNode, textFormatTransformersIndex, textMatchTransformers);
   }
 }
-
 function importTextMatchTransformers(textNode_, textMatchTransformers) {
   let textNode = textNode_;
-
   mainLoop: while (textNode) {
     for (const transformer of textMatchTransformers) {
       const match = textNode.getTextContent().match(transformer.importRegExp);
-
       if (!match) {
         continue;
       }
-
       const startIndex = match.index || 0;
       const endIndex = startIndex + match[0].length;
       let replaceNode, leftTextNode, rightTextNode;
-
       if (startIndex === 0) {
         [replaceNode, textNode] = textNode.splitText(endIndex);
       } else {
         [leftTextNode, replaceNode, rightTextNode] = textNode.splitText(startIndex, endIndex);
       }
-
       if (leftTextNode) {
         importTextMatchTransformers(leftTextNode, textMatchTransformers);
       }
-
       if (rightTextNode) {
         textNode = rightTextNode;
       }
-
       transformer.replace(replaceNode, match);
       continue mainLoop;
     }
-
     break;
   }
-} // Finds first "<tag>content<tag>" match that is not nested into another tag
-
+}
 
+// Finds first "<tag>content<tag>" match that is not nested into another tag
 function findOutermostMatch(textContent, textTransformersIndex) {
   const openTagsMatch = textContent.match(textTransformersIndex.openTagsRegExp);
-
   if (openTagsMatch == null) {
     return null;
   }
-
   for (const match of openTagsMatch) {
     // Open tags reg exp might capture leading space so removing it
     // before using match to find transformer
     const tag = match.replace(/^\s/, '');
     const fullMatchRegExp = textTransformersIndex.fullMatchRegExpByTag[tag];
-
     if (fullMatchRegExp == null) {
       continue;
     }
-
     const fullMatch = textContent.match(fullMatchRegExp);
     const transformer = textTransformersIndex.transformersByTag[tag];
-
     if (fullMatch != null && transformer != null) {
       if (transformer.intraword !== false) {
         return fullMatch;
-      } // For non-intraword transformers checking if it's within a word
-      // or surrounded with space/punctuation/newline
-
+      }
 
+      // For non-intraword transformers checking if it's within a word
+      // or surrounded with space/punctuation/newline
       const {
         index = 0
       } = fullMatch;
       const beforeChar = textContent[index - 1];
       const afterChar = textContent[index + fullMatch[0].length];
-
       if ((!beforeChar || PUNCTUATION_OR_SPACE.test(beforeChar)) && (!afterChar || PUNCTUATION_OR_SPACE.test(afterChar))) {
         return fullMatch;
       }
     }
   }
-
   return null;
 }
-
 function createTextFormatTransformersIndex(textTransformers) {
   const transformersByTag = {};
   const fullMatchRegExpByTag = {};
   const openTagsRegExp = [];
   const escapeRegExp = `(?<![\\\\])`;
-
   for (const transformer of textTransformers) {
     const {
       tag
@@ -512,14 +446,12 @@ function createTextFormatTransformersIndex(textTransformers) {
     transformersByTag[tag] = transformer;
     const tagRegExp = tag.replace(/(\*|\^|\+)/g, '\\$1');
     openTagsRegExp.push(tagRegExp);
-
     if (IS_SAFARI || IS_IOS || IS_APPLE_WEBKIT) {
       fullMatchRegExpByTag[tag] = new RegExp(`(${tagRegExp})(?![${tagRegExp}\\s])(.*?[^${tagRegExp}\\s])${tagRegExp}(?!${tagRegExp})`);
     } else {
       fullMatchRegExpByTag[tag] = new RegExp(`(?<![\\\\${tagRegExp}])(${tagRegExp})((\\\\${tagRegExp})?.*?[^${tagRegExp}\\s](\\\\${tagRegExp})?)((?<!\\\\)|(?<=\\\\\\\\))(${tagRegExp})(?![\\\\${tagRegExp}])`);
     }
   }
-
   return {
     // Reg exp to find open tag + content + close tag
     fullMatchRegExpByTag,
@@ -536,31 +468,27 @@ function createTextFormatTransformersIndex(textTransformers) {
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 function runElementTransformers(parentNode, anchorNode, anchorOffset, elementTransformers) {
   const grandParentNode = parentNode.getParent();
-
   if (!lexical.$isRootOrShadowRoot(grandParentNode) || parentNode.getFirstChild() !== anchorNode) {
     return false;
   }
+  const textContent = anchorNode.getTextContent();
 
-  const textContent = anchorNode.getTextContent(); // Checking for anchorOffset position to prevent any checks for cases when caret is too far
+  // Checking for anchorOffset position to prevent any checks for cases when caret is too far
   // from a line start to be a part of block-level markdown trigger.
   //
   // TODO:
   // Can have a quick check if caret is close enough to the beginning of the string (e.g. offset less than 10-20)
   // since otherwise it won't be a markdown shortcut, but tables are exception
-
   if (textContent[anchorOffset - 1] !== ' ') {
     return false;
   }
-
   for (const {
     regExp,
     replace
   } of elementTransformers) {
     const match = textContent.match(regExp);
-
     if (match && match[0].length === anchorOffset) {
       const nextSiblings = anchorNode.getNextSiblings();
       const [leadingNode, remainderNode] = anchorNode.splitText(anchorOffset);
@@ -570,131 +498,115 @@ function runElementTransformers(parentNode, anchorNode, anchorOffset, elementTra
       return true;
     }
   }
-
   return false;
 }
-
 function runTextMatchTransformers(anchorNode, anchorOffset, transformersByTrigger) {
   let textContent = anchorNode.getTextContent();
   const lastChar = textContent[anchorOffset - 1];
   const transformers = transformersByTrigger[lastChar];
-
   if (transformers == null) {
     return false;
-  } // If typing in the middle of content, remove the tail to do
-  // reg exp match up to a string end (caret position)
-
+  }
 
+  // If typing in the middle of content, remove the tail to do
+  // reg exp match up to a string end (caret position)
   if (anchorOffset < textContent.length) {
     textContent = textContent.slice(0, anchorOffset);
   }
-
   for (const transformer of transformers) {
     const match = textContent.match(transformer.regExp);
-
     if (match === null) {
       continue;
     }
-
     const startIndex = match.index || 0;
     const endIndex = startIndex + match[0].length;
     let replaceNode;
-
     if (startIndex === 0) {
       [replaceNode] = anchorNode.splitText(endIndex);
     } else {
       [, replaceNode] = anchorNode.splitText(startIndex, endIndex);
     }
-
     replaceNode.selectNext(0, 0);
     transformer.replace(replaceNode, match);
     return true;
   }
-
   return false;
 }
-
 function runTextFormatTransformers(anchorNode, anchorOffset, textFormatTransformers) {
   const textContent = anchorNode.getTextContent();
   const closeTagEndIndex = anchorOffset - 1;
-  const closeChar = textContent[closeTagEndIndex]; // Quick check if we're possibly at the end of inline markdown style
-
+  const closeChar = textContent[closeTagEndIndex];
+  // Quick check if we're possibly at the end of inline markdown style
   const matchers = textFormatTransformers[closeChar];
-
   if (!matchers) {
     return false;
   }
-
   for (const matcher of matchers) {
     const {
       tag
     } = matcher;
     const tagLength = tag.length;
-    const closeTagStartIndex = closeTagEndIndex - tagLength + 1; // If tag is not single char check if rest of it matches with text content
+    const closeTagStartIndex = closeTagEndIndex - tagLength + 1;
 
+    // If tag is not single char check if rest of it matches with text content
     if (tagLength > 1) {
       if (!isEqualSubString(textContent, closeTagStartIndex, tag, 0, tagLength)) {
         continue;
       }
-    } // Space before closing tag cancels inline markdown
-
+    }
 
+    // Space before closing tag cancels inline markdown
     if (textContent[closeTagStartIndex - 1] === ' ') {
       continue;
-    } // Some tags can not be used within words, hence should have newline/space/punctuation after it
-
+    }
 
+    // Some tags can not be used within words, hence should have newline/space/punctuation after it
     const afterCloseTagChar = textContent[closeTagEndIndex + 1];
-
     if (matcher.intraword === false && afterCloseTagChar && !PUNCTUATION_OR_SPACE.test(afterCloseTagChar)) {
       continue;
     }
-
     const closeNode = anchorNode;
     let openNode = closeNode;
-    let openTagStartIndex = getOpenTagStartIndex(textContent, closeTagStartIndex, tag); // Go through text node siblings and search for opening tag
-    // if haven't found it within the same text node as closing tag
+    let openTagStartIndex = getOpenTagStartIndex(textContent, closeTagStartIndex, tag);
 
+    // Go through text node siblings and search for opening tag
+    // if haven't found it within the same text node as closing tag
     let sibling = openNode;
-
     while (openTagStartIndex < 0 && (sibling = sibling.getPreviousSibling())) {
       if (lexical.$isLineBreakNode(sibling)) {
         break;
       }
-
       if (lexical.$isTextNode(sibling)) {
         const siblingTextContent = sibling.getTextContent();
         openNode = sibling;
         openTagStartIndex = getOpenTagStartIndex(siblingTextContent, siblingTextContent.length, tag);
       }
-    } // Opening tag is not found
-
+    }
 
+    // Opening tag is not found
     if (openTagStartIndex < 0) {
       continue;
-    } // No content between opening and closing tag
-
+    }
 
+    // No content between opening and closing tag
     if (openNode === closeNode && openTagStartIndex + tagLength === closeTagStartIndex) {
       continue;
-    } // Checking longer tags for repeating chars (e.g. *** vs **)
-
+    }
 
+    // Checking longer tags for repeating chars (e.g. *** vs **)
     const prevOpenNodeText = openNode.getTextContent();
-
     if (openTagStartIndex > 0 && prevOpenNodeText[openTagStartIndex - 1] === closeChar) {
       continue;
-    } // Some tags can not be used within words, hence should have newline/space/punctuation before it
-
+    }
 
+    // Some tags can not be used within words, hence should have newline/space/punctuation before it
     const beforeOpenTagChar = prevOpenNodeText[openTagStartIndex - 1];
-
     if (matcher.intraword === false && beforeOpenTagChar && !PUNCTUATION_OR_SPACE.test(beforeOpenTagChar)) {
       continue;
-    } // Clean text from opening and closing tags (starting from closing tag
-    // to prevent any offset shifts if we start from opening one)
-
+    }
 
+    // Clean text from opening and closing tags (starting from closing tag
+    // to prevent any offset shifts if we start from opening one)
     const prevCloseNodeText = closeNode.getTextContent();
     const closeNodeText = prevCloseNodeText.slice(0, closeTagStartIndex) + prevCloseNodeText.slice(closeTagEndIndex + 1);
     closeNode.setTextContent(closeNodeText);
@@ -702,62 +614,55 @@ function runTextFormatTransformers(anchorNode, anchorOffset, textFormatTransform
     openNode.setTextContent(openNodeText.slice(0, openTagStartIndex) + openNodeText.slice(openTagStartIndex + tagLength));
     const selection = lexical.$getSelection();
     const nextSelection = lexical.$createRangeSelection();
-    lexical.$setSelection(nextSelection); // Adjust offset based on deleted chars
-
+    lexical.$setSelection(nextSelection);
+    // Adjust offset based on deleted chars
     const newOffset = closeTagEndIndex - tagLength * (openNode === closeNode ? 2 : 1) + 1;
     nextSelection.anchor.set(openNode.__key, openTagStartIndex, 'text');
-    nextSelection.focus.set(closeNode.__key, newOffset, 'text'); // Apply formatting to selected text
+    nextSelection.focus.set(closeNode.__key, newOffset, 'text');
 
+    // Apply formatting to selected text
     for (const format of matcher.format) {
       if (!nextSelection.hasFormat(format)) {
         nextSelection.formatText(format);
       }
-    } // Collapse selection up to the focus point
-
+    }
 
-    nextSelection.anchor.set(nextSelection.focus.key, nextSelection.focus.offset, nextSelection.focus.type); // Remove formatting from collapsed selection
+    // Collapse selection up to the focus point
+    nextSelection.anchor.set(nextSelection.focus.key, nextSelection.focus.offset, nextSelection.focus.type);
 
+    // Remove formatting from collapsed selection
     for (const format of matcher.format) {
       if (nextSelection.hasFormat(format)) {
         nextSelection.toggleFormat(format);
       }
     }
-
     if (lexical.$isRangeSelection(selection)) {
       nextSelection.format = selection.format;
     }
-
     return true;
   }
-
   return false;
 }
-
 function getOpenTagStartIndex(string, maxIndex, tag) {
   const tagLength = tag.length;
-
   for (let i = maxIndex; i >= tagLength; i--) {
     const startIndex = i - tagLength;
-
-    if (isEqualSubString(string, startIndex, tag, 0, tagLength) && // Space after opening tag cancels transformation
+    if (isEqualSubString(string, startIndex, tag, 0, tagLength) &&
+    // Space after opening tag cancels transformation
     string[startIndex + tagLength] !== ' ') {
       return startIndex;
     }
   }
-
   return -1;
 }
-
 function isEqualSubString(stringA, aStart, stringB, bStart, length) {
   for (let i = 0; i < length; i++) {
     if (stringA[aStart + i] !== stringB[bStart + i]) {
       return false;
     }
   }
-
   return true;
 }
-
 function registerMarkdownShortcuts(editor, transformers = TRANSFORMERS) {
   const byType = transformersByType(transformers);
   const textFormatTransformersIndex = indexBy(byType.textFormat, ({
@@ -766,13 +671,10 @@ function registerMarkdownShortcuts(editor, transformers = TRANSFORMERS) {
   const textMatchTransformersIndex = indexBy(byType.textMatch, ({
     trigger
   }) => trigger);
-
   for (const transformer of transformers) {
     const type = transformer.type;
-
     if (type === 'element' || type === 'text-match') {
       const dependencies = transformer.dependencies;
-
       for (const node of dependencies) {
         if (!editor.hasNode(node)) {
           {
@@ -782,19 +684,15 @@ function registerMarkdownShortcuts(editor, transformers = TRANSFORMERS) {
       }
     }
   }
-
   const transform = (parentNode, anchorNode, anchorOffset) => {
     if (runElementTransformers(parentNode, anchorNode, anchorOffset, byType.element)) {
       return;
     }
-
     if (runTextMatchTransformers(anchorNode, anchorOffset, textMatchTransformersIndex)) {
       return;
     }
-
     runTextFormatTransformers(anchorNode, anchorOffset, textFormatTransformersIndex);
   };
-
   return editor.registerUpdateListener(({
     tags,
     dirtyLeaves,
@@ -804,41 +702,32 @@ function registerMarkdownShortcuts(editor, transformers = TRANSFORMERS) {
     // Ignore updates from undo/redo (as changes already calculated)
     if (tags.has('historic')) {
       return;
-    } // If editor is still composing (i.e. backticks) we must wait before the user confirms the key
-
+    }
 
+    // If editor is still composing (i.e. backticks) we must wait before the user confirms the key
     if (editor.isComposing()) {
       return;
     }
-
     const selection = editorState.read(lexical.$getSelection);
     const prevSelection = prevEditorState.read(lexical.$getSelection);
-
     if (!lexical.$isRangeSelection(prevSelection) || !lexical.$isRangeSelection(selection) || !selection.isCollapsed()) {
       return;
     }
-
     const anchorKey = selection.anchor.key;
     const anchorOffset = selection.anchor.offset;
-
     const anchorNode = editorState._nodeMap.get(anchorKey);
-
     if (!lexical.$isTextNode(anchorNode) || !dirtyLeaves.has(anchorKey) || anchorOffset !== 1 && anchorOffset > prevSelection.anchor.offset + 1) {
       return;
     }
-
     editor.update(() => {
       // Markdown is not available inside code
       if (anchorNode.hasFormat('code')) {
         return;
       }
-
       const parentNode = anchorNode.getParent();
-
       if (parentNode === null || code.$isCodeNode(parentNode)) {
         return;
       }
-
       transform(parentNode, anchorNode, selection.anchor.offset);
     });
   });
@@ -851,7 +740,6 @@ function registerMarkdownShortcuts(editor, transformers = TRANSFORMERS) {
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 const createBlockNode = createNode => {
   return (parentNode, children, match) => {
     const node = createNode(match);
@@ -859,28 +747,24 @@ const createBlockNode = createNode => {
     parentNode.replace(node);
     node.select(0, 0);
   };
-}; // Amount of spaces that define indentation level
-// TODO: should be an option
-
+};
 
+// Amount of spaces that define indentation level
+// TODO: should be an option
 const LIST_INDENT_SIZE = 4;
-
 const listReplace = listType => {
   return (parentNode, children, match) => {
     const previousNode = parentNode.getPreviousSibling();
     const nextNode = parentNode.getNextSibling();
     const listItem = list.$createListItemNode(listType === 'check' ? match[3] === 'x' : undefined);
-
     if (list.$isListNode(nextNode) && nextNode.getListType() === listType) {
       const firstChild = nextNode.getFirstChild();
-
       if (firstChild !== null) {
         firstChild.insertBefore(listItem);
       } else {
         // should never happen, but let's handle gracefully, just in case.
         nextNode.append(listItem);
       }
-
       parentNode.remove();
     } else if (list.$isListNode(previousNode) && previousNode.getListType() === listType) {
       previousNode.append(listItem);
@@ -890,33 +774,27 @@ const listReplace = listType => {
       list$1.append(listItem);
       parentNode.replace(list$1);
     }
-
     listItem.append(...children);
     listItem.select(0, 0);
     const indent = Math.floor(match[1].length / LIST_INDENT_SIZE);
-
     if (indent) {
       listItem.setIndent(indent);
     }
   };
 };
-
 const listExport = (listNode, exportChildren, depth) => {
   const output = [];
   const children = listNode.getChildren();
   let index = 0;
-
   for (const listItemNode of children) {
     if (list.$isListItemNode(listItemNode)) {
       if (listItemNode.getChildrenSize() === 1) {
         const firstChild = listItemNode.getFirstChild();
-
         if (list.$isListNode(firstChild)) {
           output.push(listExport(firstChild, exportChildren, depth + 1));
           continue;
         }
       }
-
       const indent = ' '.repeat(depth * LIST_INDENT_SIZE);
       const listType = listNode.getListType();
       const prefix = listType === 'number' ? `${listNode.getStart() + index}. ` : listType === 'check' ? `- [${listItemNode.getChecked() ? 'x' : ' '}] ` : '- ';
@@ -924,17 +802,14 @@ const listExport = (listNode, exportChildren, depth) => {
       index++;
     }
   }
-
   return output.join('\n');
 };
-
 const HEADING = {
   dependencies: [richText.HeadingNode],
   export: (node, exportChildren) => {
     if (!richText.$isHeadingNode(node)) {
       return null;
     }
-
     const level = Number(node.getTag().slice(1));
     return '#'.repeat(level) + ' ' + exportChildren(node);
   },
@@ -951,21 +826,17 @@ const QUOTE = {
     if (!richText.$isQuoteNode(node)) {
       return null;
     }
-
     const lines = exportChildren(node).split('\n');
     const output = [];
-
     for (const line of lines) {
       output.push('> ' + line);
     }
-
     return output.join('\n');
   },
   regExp: /^>\s/,
   replace: (parentNode, children, _match, isImport) => {
     if (isImport) {
       const previousNode = parentNode.getPreviousSibling();
-
       if (richText.$isQuoteNode(previousNode)) {
         previousNode.splice(previousNode.getChildrenSize(), 0, [lexical.$createLineBreakNode(), ...children]);
         previousNode.select(0, 0);
@@ -973,7 +844,6 @@ const QUOTE = {
         return;
       }
     }
-
     const node = richText.$createQuoteNode();
     node.append(...children);
     parentNode.replace(node);
@@ -987,7 +857,6 @@ const CODE = {
     if (!code.$isCodeNode(node)) {
       return null;
     }
-
     const textContent = node.getTextContent();
     return '```' + (node.getLanguage() || '') + (textContent ? '\n' + textContent : '') + '\n' + '```';
   },
@@ -1071,23 +940,23 @@ const ITALIC_UNDERSCORE = {
   intraword: false,
   tag: '_',
   type: 'text-format'
-}; // Order of text transformers matters:
+};
+
+// Order of text transformers matters:
 //
 // - code should go first as it prevents any transformations inside
 // - then longer tags match (e.g. ** or __ should go before * or _)
-
 const LINK = {
   dependencies: [link.LinkNode],
   export: (node, exportChildren, exportFormat) => {
     if (!link.$isLinkNode(node)) {
       return null;
     }
-
     const title = node.getTitle();
     const linkContent = title ? `[${node.getTextContent()}](${node.getURL()} "${title}")` : `[${node.getTextContent()}](${node.getURL()})`;
-    const firstChild = node.getFirstChild(); // Add text styles only if link has single text node inside. If it's more
+    const firstChild = node.getFirstChild();
+    // Add text styles only if link has single text node inside. If it's more
     // then one we ignore it as markdown does not support nested styles for links
-
     if (node.getChildrenSize() === 1 && lexical.$isTextNode(firstChild)) {
       return exportFormat(firstChild, linkContent);
     } else {
@@ -1111,20 +980,19 @@ const LINK = {
 };
 
 /** @module @lexical/markdown */
-const ELEMENT_TRANSFORMERS = [HEADING, QUOTE, CODE, UNORDERED_LIST, ORDERED_LIST]; // Order of text format transformers matters:
+const ELEMENT_TRANSFORMERS = [HEADING, QUOTE, CODE, UNORDERED_LIST, ORDERED_LIST];
+
+// Order of text format transformers matters:
 //
 // - code should go first as it prevents any transformations inside
 // - then longer tags match (e.g. ** or __ should go before * or _)
-
 const TEXT_FORMAT_TRANSFORMERS = [INLINE_CODE, BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, HIGHLIGHT, ITALIC_STAR, ITALIC_UNDERSCORE, STRIKETHROUGH];
 const TEXT_MATCH_TRANSFORMERS = [LINK];
 const TRANSFORMERS = [...ELEMENT_TRANSFORMERS, ...TEXT_FORMAT_TRANSFORMERS, ...TEXT_MATCH_TRANSFORMERS];
-
 function $convertFromMarkdownString(markdown, transformers = TRANSFORMERS, node) {
   const importMarkdown = createMarkdownImport(transformers);
   return importMarkdown(markdown, node);
 }
-
 function $convertToMarkdownString(transformers = TRANSFORMERS, node) {
   const exportMarkdown = createMarkdownExport(transformers);
   return exportMarkdown(node);

package/LexicalMarkdown.prod.js

@@ -4,26 +4,26 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-'use strict';var k=require("lexical"),t=require("@lexical/code"),A=require("@lexical/list"),B=require("@lexical/rich-text"),aa=require("@lexical/utils"),G=require("@lexical/link");function H(a,b){let c={};for(let d of a)a=b(d),c[a]?c[a].push(d):c[a]=[d];return c}function I(a){a=H(a,b=>b.type);return{element:a.element||[],textFormat:a["text-format"]||[],textMatch:a["text-match"]||[]}}let J=/[!-/:-@[-`{-~\s]/;
+'use strict';var k=require("lexical"),t=require("@lexical/code"),z=require("@lexical/list"),B=require("@lexical/rich-text"),aa=require("@lexical/utils"),G=require("@lexical/link");function H(a,b){let c={};for(let d of a)a=b(d),c[a]?c[a].push(d):c[a]=[d];return c}function I(a){a=H(a,b=>b.type);return{element:a.element||[],textFormat:a["text-format"]||[],textMatch:a["text-match"]||[]}}let J=/[!-/:-@[-`{-~\s]/;
 function ba(a){let b=I(a),c=b.textFormat.filter(d=>1===d.format.length);return d=>{let e=[];d=(d||k.$getRoot()).getChildren();for(let f of d)d=ca(f,b.element,c,b.textMatch),null!=d&&e.push(d);return e.join("\n\n")}}function ca(a,b,c,d){for(let e of b)if(b=e.export(a,f=>K(f,c,d)),null!=b)return b;return k.$isElementNode(a)?K(a,c,d):k.$isDecoratorNode(a)?a.getTextContent():null}
 function K(a,b,c){let d=[];a=a.getChildren();a:for(let e of a){for(let f of c)if(a=f.export(e,g=>K(g,b,c),(g,l)=>L(g,l,b)),null!=a){d.push(a);continue a}k.$isLineBreakNode(e)?d.push("\n"):k.$isTextNode(e)?d.push(L(e,e.getTextContent(),b)):k.$isElementNode(e)?d.push(K(e,b,c)):k.$isDecoratorNode(e)&&d.push(e.getTextContent())}return d.join("")}
 function L(a,b,c){let d=b.trim(),e=d,f=new Set;for(let l of c){c=l.format[0];let p=l.tag;if(M(a,c)&&!f.has(c)){f.add(c);var g=N(a,!0);M(g,c)||(e=p+e);g=N(a,!1);M(g,c)||(e+=p)}}return b.replace(d,e)}
 function N(a,b){let c=b?a.getPreviousSibling():a.getNextSibling();c||(a=a.getParentOrThrow(),a.isInline()&&(c=b?a.getPreviousSibling():a.getNextSibling()));for(;c;){if(k.$isElementNode(c)){if(!c.isInline())break;a=b?c.getLastDescendant():c.getFirstDescendant();if(k.$isTextNode(a))return a;c=b?c.getPreviousSibling():c.getNextSibling()}if(k.$isTextNode(c))return c;if(!k.$isElementNode(c))break}return null}function M(a,b){return k.$isTextNode(a)&&a.hasFormat(b)}
-let O="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement,da=O&&"documentMode"in document?document.documentMode:null;O&&/Mac|iPod|iPhone|iPad/.test(navigator.platform);O&&/^(?!.*Seamonkey)(?=.*Firefox).*/i.test(navigator.userAgent);O&&"InputEvent"in window&&!da?"getTargetRanges"in new window.InputEvent("input"):!1;
-let P=O&&/Version\/[\d.]+.*Safari/.test(navigator.userAgent),Q=O&&/iPad|iPhone|iPod/.test(navigator.userAgent)&&!window.MSStream,ea=O&&/^(?=.*Chrome).*/i.test(navigator.userAgent),R=O&&/AppleWebKit\/[\d.]+/.test(navigator.userAgent)&&!ea,fa=/^\s{0,3}$/,S=/^```(\w{1,10})?\s?$/;
+let O="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement,da=O&&"documentMode"in document?document.documentMode:null;O&&/Mac|iPod|iPhone|iPad/.test(navigator.platform);O&&/^(?!.*Seamonkey)(?=.*Firefox).*/i.test(navigator.userAgent);O&&"InputEvent"in window&&!da?"getTargetRanges"in new window.InputEvent("input"):!1;let P=O&&/Version\/[\d.]+.*Safari/.test(navigator.userAgent),Q=O&&/iPad|iPhone|iPod/.test(navigator.userAgent)&&!window.MSStream;
+O&&/Android/.test(navigator.userAgent);let ea=O&&/^(?=.*Chrome).*/i.test(navigator.userAgent),R=O&&/AppleWebKit\/[\d.]+/.test(navigator.userAgent)&&!ea,fa=/^\s{0,3}$/,S=/^```(\w{1,10})?\s?$/;
 function ha(a){let b=I(a),c=ia(b.textFormat);return(d,e)=>{d=d.split("\n");var f=d.length;e=e||k.$getRoot();e.clear();for(let h=0;h<f;h++){var g=d[h];a:{var l=d,p=h;var r=e;var y=l[p].match(S);if(y)for(var q=p,m=l.length;++q<m;)if(l[q].match(S)){y=t.$createCodeNode(y[1]);l=k.$createTextNode(l.slice(p+1,q).join("\n"));y.append(l);r.append(y);r=[y,q];break a}r=[null,p]}let [n,v]=r;if(null!=n)h=v;else{r=g;m=e;var w=b.element;q=c;l=b.textMatch;p=r.trim();y=k.$createTextNode(p);g=k.$createParagraphNode();
-g.append(y);m.append(g);for(let {regExp:x,replace:u}of w)if(m=r.match(x)){y.setTextContent(r.slice(m[0].length));u(g,[y],m,!0);break}T(y,q,l);g.isAttached()&&0<p.length&&(r=g.getPreviousSibling(),k.$isParagraphNode(r)||B.$isQuoteNode(r)||A.$isListNode(r))&&(q=r,A.$isListNode(r)&&(r=r.getLastDescendant(),q=null==r?null:aa.$findMatchingParent(r,A.$isListItemNode)),null!=q&&0<q.getTextContentSize()&&(q.splice(q.getChildrenSize(),0,[k.$createLineBreakNode(),...g.getChildren()]),g.remove()))}}d=e.getChildren();
+g.append(y);m.append(g);for(let {regExp:x,replace:u}of w)if(m=r.match(x)){y.setTextContent(r.slice(m[0].length));u(g,[y],m,!0);break}T(y,q,l);g.isAttached()&&0<p.length&&(r=g.getPreviousSibling(),k.$isParagraphNode(r)||B.$isQuoteNode(r)||z.$isListNode(r))&&(q=r,z.$isListNode(r)&&(r=r.getLastDescendant(),q=null==r?null:aa.$findMatchingParent(r,z.$isListItemNode)),null!=q&&0<q.getTextContentSize()&&(q.splice(q.getChildrenSize(),0,[k.$createLineBreakNode(),...g.getChildren()]),g.remove()))}}d=e.getChildren();
 for(let h of d)d=h,k.$isParagraphNode(d)?(f=d.getFirstChild(),d=null==f||1===d.getChildrenSize()&&k.$isTextNode(f)&&fa.test(f.getTextContent())):d=!1,d&&h.remove();null!==k.$getSelection()&&e.selectEnd()}}
 function T(a,b,c){var d=a.getTextContent();let e=ja(d,b);if(e){var f,g;if(e[0]===d)var l=a;else{d=e.index||0;let p=d+e[0].length;0===d?[l,f]=a.splitText(p):[g,l,f]=a.splitText(d,p)}l.setTextContent(e[2]);if(a=b.transformersByTag[e[1]])for(let p of a.format)l.hasFormat(p)||l.toggleFormat(p);l.hasFormat("code")||T(l,b,c);g&&T(g,b,c);f&&T(f,b,c)}else U(a,c)}
 function U(a,b){a:for(;a;){for(let c of b){let d=a.getTextContent().match(c.importRegExp);if(!d)continue;let e=d.index||0,f=e+d[0].length,g,l,p;0===e?[g,a]=a.splitText(f):[l,g,p]=a.splitText(e,f);l&&U(l,b);p&&(a=p);c.replace(g,d);continue a}break}}
 function ja(a,b){var c=a.match(b.openTagsRegExp);if(null==c)return null;for(let f of c){var d=f.replace(/^\s/,"");c=b.fullMatchRegExpByTag[d];if(null!=c&&(c=a.match(c),d=b.transformersByTag[d],null!=c&&null!=d)){if(!1!==d.intraword)return c;var {index:e=0}=c;d=a[e-1];e=a[e+c[0].length];if(!(d&&!J.test(d)||e&&!J.test(e)))return c}}return null}
 function ia(a){let b={},c={},d=[];for(let e of a){({tag:a}=e);b[a]=e;let f=a.replace(/(\*|\^|\+)/g,"\\$1");d.push(f);c[a]=P||Q||R?new RegExp(`(${f})(?![${f}\\s])(.*?[^${f}\\s])${f}(?!${f})`):new RegExp(`(?<![\\\\${f}])(${f})((\\\\${f})?.*?[^${f}\\s](\\\\${f})?)((?<!\\\\)|(?<=\\\\\\\\))(${f})(?![\\\\${f}])`)}return{fullMatchRegExpByTag:c,openTagsRegExp:new RegExp((P||Q||R?"":"(?<![\\\\])")+"("+d.join("|")+")","g"),transformersByTag:b}}
 function V(a,b,c){let d=c.length;for(;b>=d;b--){let e=b-d;if(W(a,e,c,0,d)&&" "!==a[e+d])return e}return-1}function W(a,b,c,d,e){for(let f=0;f<e;f++)if(a[b+f]!==c[d+f])return!1;return!0}
-let ka=a=>(b,c,d)=>{d=a(d);d.append(...c);b.replace(d);d.select(0,0)},X=a=>(b,c,d)=>{var e=b.getPreviousSibling(),f=b.getNextSibling();const g=A.$createListItemNode("check"===a?"x"===d[3]:void 0);A.$isListNode(f)&&f.getListType()===a?(e=f.getFirstChild(),null!==e?e.insertBefore(g):f.append(g),b.remove()):A.$isListNode(e)&&e.getListType()===a?(e.append(g),b.remove()):(f=A.$createListNode(a,"number"===a?Number(d[2]):void 0),f.append(g),b.replace(f));g.append(...c);g.select(0,0);(b=Math.floor(d[1].length/
-4))&&g.setIndent(b)},Y=(a,b,c)=>{const d=[];var e=a.getChildren();let f=0;for(const l of e)if(A.$isListItemNode(l)){if(1===l.getChildrenSize()&&(e=l.getFirstChild(),A.$isListNode(e))){d.push(Y(e,b,c+1));continue}e=" ".repeat(4*c);var g=a.getListType();g="number"===g?`${a.getStart()+f}. `:"check"===g?`- [${l.getChecked()?"x":" "}] `:"- ";d.push(e+g+b(l));f++}return d.join("\n")},la={dependencies:[B.HeadingNode],export:(a,b)=>{if(!B.$isHeadingNode(a))return null;const c=Number(a.getTag().slice(1));
+let ka=a=>(b,c,d)=>{d=a(d);d.append(...c);b.replace(d);d.select(0,0)},X=a=>(b,c,d)=>{var e=b.getPreviousSibling(),f=b.getNextSibling();const g=z.$createListItemNode("check"===a?"x"===d[3]:void 0);z.$isListNode(f)&&f.getListType()===a?(e=f.getFirstChild(),null!==e?e.insertBefore(g):f.append(g),b.remove()):z.$isListNode(e)&&e.getListType()===a?(e.append(g),b.remove()):(f=z.$createListNode(a,"number"===a?Number(d[2]):void 0),f.append(g),b.replace(f));g.append(...c);g.select(0,0);(b=Math.floor(d[1].length/
+4))&&g.setIndent(b)},Y=(a,b,c)=>{const d=[];var e=a.getChildren();let f=0;for(const l of e)if(z.$isListItemNode(l)){if(1===l.getChildrenSize()&&(e=l.getFirstChild(),z.$isListNode(e))){d.push(Y(e,b,c+1));continue}e=" ".repeat(4*c);var g=a.getListType();g="number"===g?`${a.getStart()+f}. `:"check"===g?`- [${l.getChecked()?"x":" "}] `:"- ";d.push(e+g+b(l));f++}return d.join("\n")},la={dependencies:[B.HeadingNode],export:(a,b)=>{if(!B.$isHeadingNode(a))return null;const c=Number(a.getTag().slice(1));
 return"#".repeat(c)+" "+b(a)},regExp:/^(#{1,6})\s/,replace:ka(a=>B.$createHeadingNode("h"+a[1].length)),type:"element"},ma={dependencies:[B.QuoteNode],export:(a,b)=>{if(!B.$isQuoteNode(a))return null;a=b(a).split("\n");b=[];for(const c of a)b.push("> "+c);return b.join("\n")},regExp:/^>\s/,replace:(a,b,c,d)=>{if(d&&(c=a.getPreviousSibling(),B.$isQuoteNode(c))){c.splice(c.getChildrenSize(),0,[k.$createLineBreakNode(),...b]);c.select(0,0);a.remove();return}c=B.$createQuoteNode();c.append(...b);a.replace(c);
-c.select(0,0)},type:"element"},na={dependencies:[t.CodeNode],export:a=>{if(!t.$isCodeNode(a))return null;const b=a.getTextContent();return"```"+(a.getLanguage()||"")+(b?"\n"+b:"")+"\n```"},regExp:/^```(\w{1,10})?\s/,replace:ka(a=>t.$createCodeNode(a?a[1]:void 0)),type:"element"},oa={dependencies:[A.ListNode,A.ListItemNode],export:(a,b)=>A.$isListNode(a)?Y(a,b,0):null,regExp:/^(\s*)[-*+]\s/,replace:X("bullet"),type:"element"},pa={dependencies:[A.ListNode,A.ListItemNode],export:(a,b)=>A.$isListNode(a)?
-Y(a,b,0):null,regExp:/^(\s*)(?:-\s)?\s?(\[(\s|x)?\])\s/i,replace:X("check"),type:"element"},qa={dependencies:[A.ListNode,A.ListItemNode],export:(a,b)=>A.$isListNode(a)?Y(a,b,0):null,regExp:/^(\s*)(\d{1,})\.\s/,replace:X("number"),type:"element"},ra={format:["code"],tag:"`",type:"text-format"},sa={format:["highlight"],tag:"==",type:"text-format"},ta={format:["bold","italic"],tag:"***",type:"text-format"},va={format:["bold","italic"],intraword:!1,tag:"___",type:"text-format"},wa={format:["bold"],tag:"**",
+c.select(0,0)},type:"element"},na={dependencies:[t.CodeNode],export:a=>{if(!t.$isCodeNode(a))return null;const b=a.getTextContent();return"```"+(a.getLanguage()||"")+(b?"\n"+b:"")+"\n```"},regExp:/^```(\w{1,10})?\s/,replace:ka(a=>t.$createCodeNode(a?a[1]:void 0)),type:"element"},oa={dependencies:[z.ListNode,z.ListItemNode],export:(a,b)=>z.$isListNode(a)?Y(a,b,0):null,regExp:/^(\s*)[-*+]\s/,replace:X("bullet"),type:"element"},pa={dependencies:[z.ListNode,z.ListItemNode],export:(a,b)=>z.$isListNode(a)?
+Y(a,b,0):null,regExp:/^(\s*)(?:-\s)?\s?(\[(\s|x)?\])\s/i,replace:X("check"),type:"element"},qa={dependencies:[z.ListNode,z.ListItemNode],export:(a,b)=>z.$isListNode(a)?Y(a,b,0):null,regExp:/^(\s*)(\d{1,})\.\s/,replace:X("number"),type:"element"},ra={format:["code"],tag:"`",type:"text-format"},sa={format:["highlight"],tag:"==",type:"text-format"},ta={format:["bold","italic"],tag:"***",type:"text-format"},va={format:["bold","italic"],intraword:!1,tag:"___",type:"text-format"},wa={format:["bold"],tag:"**",
 type:"text-format"},xa={format:["bold"],intraword:!1,tag:"__",type:"text-format"},ya={format:["strikethrough"],tag:"~~",type:"text-format"},za={format:["italic"],tag:"*",type:"text-format"},Aa={format:["italic"],intraword:!1,tag:"_",type:"text-format"},Ba={dependencies:[G.LinkNode],export:(a,b,c)=>{if(!G.$isLinkNode(a))return null;b=(b=a.getTitle())?`[${a.getTextContent()}](${a.getURL()} "${b}")`:`[${a.getTextContent()}](${a.getURL()})`;const d=a.getFirstChild();return 1===a.getChildrenSize()&&k.$isTextNode(d)?
 c(d,b):b},importRegExp:/(?:\[([^[]+)\])(?:\((?:([^()\s]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?)\))/,regExp:/(?:\[([^[]+)\])(?:\((?:([^()\s]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?)\))$/,replace:(a,b)=>{const [,c,d,e]=b;b=G.$createLinkNode(d,{title:e});const f=k.$createTextNode(c);f.setFormat(a.getFormat());b.append(f);a.replace(b)},trigger:")",type:"text-match"},Ca=[la,ma,na,oa,qa],Da=[ra,ta,va,wa,xa,sa,za,Aa,ya],Ea=[Ba],Z=[...Ca,...Da,...Ea];
 exports.$convertFromMarkdownString=function(a,b=Z,c){return ha(b)(a,c)};exports.$convertToMarkdownString=function(a=Z,b){return ba(a)(b)};exports.BOLD_ITALIC_STAR=ta;exports.BOLD_ITALIC_UNDERSCORE=va;exports.BOLD_STAR=wa;exports.BOLD_UNDERSCORE=xa;exports.CHECK_LIST=pa;exports.CODE=na;exports.ELEMENT_TRANSFORMERS=Ca;exports.HEADING=la;exports.HIGHLIGHT=sa;exports.INLINE_CODE=ra;exports.ITALIC_STAR=za;exports.ITALIC_UNDERSCORE=Aa;exports.LINK=Ba;exports.ORDERED_LIST=qa;exports.QUOTE=ma;
@@ -31,5 +31,5 @@ exports.STRIKETHROUGH=ya;exports.TEXT_FORMAT_TRANSFORMERS=Da;exports.TEXT_MATCH_
 exports.registerMarkdownShortcuts=function(a,b=Z){let c=I(b),d=H(c.textFormat,({tag:f})=>f[f.length-1]),e=H(c.textMatch,({trigger:f})=>f);for(let f of b)if(b=f.type,"element"===b||"text-match"===b){b=f.dependencies;for(let g of b)if(!a.hasNode(g))throw Error(`MarkdownShortcuts: missing dependency ${g.getType()} for transformer. Ensure node dependency is included in editor initial config.`);}return a.registerUpdateListener(({tags:f,dirtyLeaves:g,editorState:l,prevEditorState:p})=>{if(!f.has("historic")&&
 !a.isComposing()){var r=l.read(k.$getSelection);f=p.read(k.$getSelection);if(k.$isRangeSelection(f)&&k.$isRangeSelection(r)&&r.isCollapsed()){p=r.anchor.key;var y=r.anchor.offset,q=l._nodeMap.get(p);!k.$isTextNode(q)||!g.has(p)||1!==y&&y>f.anchor.offset+1||a.update(()=>{if(!q.hasFormat("code")){var m=q.getParent();if(null!==m&&!t.$isCodeNode(m)){var w=r.anchor.offset;b:{var h=c.element,n=m.getParent();if(k.$isRootOrShadowRoot(n)&&m.getFirstChild()===q&&(n=q.getTextContent()," "===n[w-1]))for(let {regExp:D,
 replace:E}of h)if((h=n.match(D))&&h[0].length===w){n=q.getNextSiblings();let [F,ua]=q.splitText(w);F.remove();n=ua?[ua,...n]:n;E(m,n,h,!1);m=!0;break b}m=!1}if(!m){b:{h=q.getTextContent();m=e[h[w-1]];if(null!=m){w<h.length&&(h=h.slice(0,w));for(x of m)if(m=h.match(x.regExp),null!==m){h=m.index||0;n=h+m[0].length;var v=void 0;0===h?[v]=q.splitText(n):[,v]=q.splitText(h,n);v.selectNext(0,0);x.replace(v,m);var x=!0;break b}}x=!1}if(!x)b:{n=q.getTextContent();--w;var u=n[w];if(x=d[u])for(let D of x){var {tag:C}=
-D;x=C.length;let E=w-x+1;if(!(1<x&&!W(n,E,C,0,x)||" "===n[E-1])&&(v=n[w+1],!1!==D.intraword||!v||J.test(v))){m=v=q;h=V(n,E,C);for(var z=m;0>h&&(z=z.getPreviousSibling())&&!k.$isLineBreakNode(z);)k.$isTextNode(z)&&(h=z.getTextContent(),m=z,h=V(h,h.length,C));if(!(0>h||m===v&&h+x===E||(C=m.getTextContent(),0<h&&C[h-1]===u||(z=C[h-1],!1===D.intraword&&z&&!J.test(z))))){n=v.getTextContent();n=n.slice(0,E)+n.slice(w+1);v.setTextContent(n);n=m===v?n:C;m.setTextContent(n.slice(0,h)+n.slice(h+x));n=k.$getSelection();
+D;x=C.length;let E=w-x+1;if(!(1<x&&!W(n,E,C,0,x)||" "===n[E-1])&&(v=n[w+1],!1!==D.intraword||!v||J.test(v))){m=v=q;h=V(n,E,C);for(var A=m;0>h&&(A=A.getPreviousSibling())&&!k.$isLineBreakNode(A);)k.$isTextNode(A)&&(h=A.getTextContent(),m=A,h=V(h,h.length,C));if(!(0>h||m===v&&h+x===E||(C=m.getTextContent(),0<h&&C[h-1]===u||(A=C[h-1],!1===D.intraword&&A&&!J.test(A))))){n=v.getTextContent();n=n.slice(0,E)+n.slice(w+1);v.setTextContent(n);n=m===v?n:C;m.setTextContent(n.slice(0,h)+n.slice(h+x));n=k.$getSelection();
 u=k.$createRangeSelection();k.$setSelection(u);w=w-x*(m===v?2:1)+1;u.anchor.set(m.__key,h,"text");u.focus.set(v.__key,w,"text");for(let F of D.format)u.hasFormat(F)||u.formatText(F);u.anchor.set(u.focus.key,u.focus.offset,u.focus.type);for(let F of D.format)u.hasFormat(F)&&u.toggleFormat(F);k.$isRangeSelection(n)&&(u.format=n.format);break b}}}}}}}})}}})}

package/package.json

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