@lexical/markdown 0.8.1 → 0.9.1

package/LexicalMarkdown.dev.js

@@ -20,16 +20,20 @@ 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) {
@@ -50,30 +54,35 @@ const PUNCTUATION_OR_SPACE = /[!-/:-@[-`{-~\s]/;
  *
  */
 function createMarkdownExport(transformers) {
-  const byType = transformersByType(transformers);
-
-  // Export only uses text formats that are responsible for single format
+  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 () => {
+  return node => {
     const output = [];
-    const children = lexical.$getRoot().getChildren();
+    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)) {
@@ -82,17 +91,21 @@ 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)) {
@@ -103,8 +116,10 @@ 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   **"
@@ -113,61 +128,74 @@ 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
+  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)
+
+
 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);
 }
@@ -179,7 +207,6 @@ 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';
 
 /**
@@ -194,12 +221,10 @@ 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.
+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_CHROME = CAN_USE_DOM && /^(?=.*Chrome).*/i.test(navigator.userAgent);
-// export const canUseTextInputEvent: boolean = CAN_USE_DOM && 'TextEvent' in window && !documentMode;
+
+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;
 
@@ -215,77 +240,89 @@ const CODE_BLOCK_REG_EXP = /^```(\w{1,10})?\s?$/;
 function createMarkdownImport(transformers) {
   const byType = transformersByType(transformers);
   const textFormatTransformersIndex = createTextFormatTransformersIndex(byType.textFormat);
-  return markdownString => {
+  return (markdownString, node) => {
     const lines = markdownString.split('\n');
     const linesLength = lines.length;
-    const root = lexical.$getRoot();
+    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
+      importBlocks(lineText, root, byType.element, textFormatTransformersIndex, byType.textMatch);
+    } // 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();
       }
     }
-    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);
 
-  // If no transformer found and we left with original paragraph node
+  importTextFormatTransformers(textNode, textFormatTransformersIndex, textMatchTransformers); // 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();
@@ -293,13 +330,17 @@ 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'));
@@ -309,133 +350,157 @@ function importCodeBlock(lines, startLineIndex, rootNode) {
       }
     }
   }
-  return [null, startLineIndex];
-}
 
-// Processing text content and replaces text format tags.
+  return [null, startLineIndex];
+} // 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;
 
-  // If matching full content there's no need to run splitText and can reuse existing textNode
+  let currentNode, remainderNode, leadingNode; // 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
+      } // 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
@@ -443,12 +508,14 @@ 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,
@@ -465,27 +532,31 @@ 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();
 
-  // Checking for anchorOffset position to prevent any checks for cases when caret is too far
+  const textContent = anchorNode.getTextContent(); // 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);
@@ -495,115 +566,131 @@ 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
+  } // 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;
+    const closeTagStartIndex = closeTagEndIndex - tagLength + 1; // If tag is not single char check if rest of it matches with text content
 
-    // 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
+    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
+    } // 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);
@@ -611,55 +698,62 @@ 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');
+    nextSelection.focus.set(closeNode.__key, newOffset, 'text'); // Apply formatting to selected 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
+
 
-    // Collapse selection up to the focus point
-    nextSelection.anchor.set(nextSelection.focus.key, nextSelection.focus.offset, nextSelection.focus.type);
+    nextSelection.anchor.set(nextSelection.focus.key, nextSelection.focus.offset, nextSelection.focus.type); // Remove formatting from collapsed selection
 
-    // 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, ({
@@ -668,10 +762,13 @@ 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;
+
       if (!editor.hasNodes(dependencies)) {
         {
           throw Error(`MarkdownShortcuts: missing dependency for transformer. Ensure node dependency is included in editor initial config.`);
@@ -679,15 +776,19 @@ 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,
@@ -698,26 +799,35 @@ function registerMarkdownShortcuts(editor, transformers = TRANSFORMERS) {
     if (tags.has('historic')) {
       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);
     });
   });
@@ -730,6 +840,7 @@ 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);
@@ -737,15 +848,17 @@ const createBlockNode = createNode => {
     parentNode.replace(node);
     node.select(0, 0);
   };
-};
-
-// Amount of spaces that define indentation level
+}; // 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 listItem = list.$createListItemNode(listType === 'check' ? match[3] === 'x' : undefined);
+
     if (list.$isListNode(previousNode) && previousNode.getListType() === listType) {
       previousNode.append(listItem);
       parentNode.remove();
@@ -754,27 +867,33 @@ 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' : ' '}] ` : '- ';
@@ -782,14 +901,17 @@ 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);
   },
@@ -806,17 +928,21 @@ 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);
@@ -824,6 +950,7 @@ const QUOTE = {
         return;
       }
     }
+
     const node = richText.$createQuoteNode();
     node.append(...children);
     parentNode.replace(node);
@@ -837,6 +964,7 @@ const CODE = {
     if (!code.$isCodeNode(node)) {
       return null;
     }
+
     const textContent = node.getTextContent();
     return '```' + (node.getLanguage() || '') + (textContent ? '\n' + textContent : '') + '\n' + '```';
   },
@@ -920,22 +1048,22 @@ 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 linkContent = `[${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 {
@@ -957,22 +1085,23 @@ 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) {
+
+function $convertFromMarkdownString(markdown, transformers = TRANSFORMERS, node) {
   const importMarkdown = createMarkdownImport(transformers);
-  return importMarkdown(markdown);
+  return importMarkdown(markdown, node);
 }
-function $convertToMarkdownString(transformers = TRANSFORMERS) {
+
+function $convertToMarkdownString(transformers = TRANSFORMERS, node) {
   const exportMarkdown = createMarkdownExport(transformers);
-  return exportMarkdown();
+  return exportMarkdown(node);
 }
 
 exports.$convertFromMarkdownString = $convertFromMarkdownString;

package/LexicalMarkdown.prod.js

@@ -5,15 +5,15 @@
  * LICENSE file in the root directory of this source tree.
  */
 'use strict';var h=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]/;
-function ba(a){let b=I(a),c=b.textFormat.filter(d=>1===d.format.length);return()=>{let d=[];var e=h.$getRoot().getChildren();for(let f of e)e=ca(f,b.element,c,b.textMatch),null!=e&&d.push(e);return d.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 h.$isElementNode(a)?K(a,c,d):h.$isDecoratorNode(a)?a.getTextContent():null}
+function ba(a){let b=I(a),c=b.textFormat.filter(d=>1===d.format.length);return d=>{let e=[];d=(d||h.$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 h.$isElementNode(a)?K(a,c,d):h.$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,l=>K(l,b,c),(l,k)=>L(l,k,b)),null!=a){d.push(a);continue a}h.$isLineBreakNode(e)?d.push("\n"):h.$isTextNode(e)?d.push(L(e,e.getTextContent(),b)):h.$isElementNode(e)?d.push(K(e,b,c)):h.$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 k of c){c=k.format[0];let p=k.tag;if(M(a,c)&&!f.has(c)){f.add(c);var l=N(a,!0);M(l,c)||(e=p+e);l=N(a,!1);M(l,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(h.$isElementNode(c)){if(!c.isInline())break;a=b?c.getLastDescendant():c.getFirstDescendant();if(h.$isTextNode(a))return a;c=b?c.getPreviousSibling():c.getNextSibling()}if(h.$isTextNode(c))return c;if(!h.$isElementNode(c))break}return null}function M(a,b){return h.$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?$/;
-function ha(a){let b=I(a),c=ia(b.textFormat);return d=>{var e=d.split("\n"),f=e.length;d=h.$getRoot();d.clear();for(let g=0;g<f;g++){var l=e[g];a:{var k=e,p=g;var r=d;var y=k[p].match(S);if(y)for(var q=p,m=k.length;++q<m;)if(k[q].match(S)){y=t.$createCodeNode(y[1]);k=h.$createTextNode(k.slice(p+1,q).join("\n"));y.append(k);r.append(y);r=[y,q];break a}r=[null,p]}let [n,v]=r;if(null!=n)g=v;else{r=l;m=d;var w=b.element;q=c;k=b.textMatch;p=r.trim();y=h.$createTextNode(p);l=h.$createParagraphNode();l.append(y);
-m.append(l);for(let {regExp:x,replace:u}of w)if(m=r.match(x)){y.setTextContent(r.slice(m[0].length));u(l,[y],m,!0);break}T(y,q,k);l.isAttached()&&0<p.length&&(r=l.getPreviousSibling(),h.$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,[h.$createLineBreakNode(),...l.getChildren()]),l.remove()))}}e=d.getChildren();for(let g of e)e=
-g,h.$isParagraphNode(e)?(f=e.getFirstChild(),e=null==f||1===e.getChildrenSize()&&h.$isTextNode(f)&&fa.test(f.getTextContent())):e=!1,e&&g.remove();d.selectEnd()}}
+function ha(a){let b=I(a),c=ia(b.textFormat);return(d,e)=>{d=d.split("\n");var f=d.length;e=e||h.$getRoot();e.clear();for(let g=0;g<f;g++){var l=d[g];a:{var k=d,p=g;var r=e;var y=k[p].match(S);if(y)for(var q=p,m=k.length;++q<m;)if(k[q].match(S)){y=t.$createCodeNode(y[1]);k=h.$createTextNode(k.slice(p+1,q).join("\n"));y.append(k);r.append(y);r=[y,q];break a}r=[null,p]}let [n,v]=r;if(null!=n)g=v;else{r=l;m=e;var w=b.element;q=c;k=b.textMatch;p=r.trim();y=h.$createTextNode(p);l=h.$createParagraphNode();
+l.append(y);m.append(l);for(let {regExp:x,replace:u}of w)if(m=r.match(x)){y.setTextContent(r.slice(m[0].length));u(l,[y],m,!0);break}T(y,q,k);l.isAttached()&&0<p.length&&(r=l.getPreviousSibling(),h.$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,[h.$createLineBreakNode(),...l.getChildren()]),l.remove()))}}d=e.getChildren();
+for(let g of d)d=g,h.$isParagraphNode(d)?(f=d.getFirstChild(),d=null==f||1===d.getChildrenSize()&&h.$isTextNode(f)&&fa.test(f.getTextContent())):d=!1,d&&g.remove()}}
 function T(a,b,c){var d=a.getTextContent();let e=ja(d,b);if(e){var f,l;if(e[0]===d)var k=a;else{d=e.index||0;let p=d+e[0].length;0===d?[k,f]=a.splitText(p):[l,k,f]=a.splitText(d,p)}k.setTextContent(e[2]);if(a=b.transformersByTag[e[1]])for(let p of a.format)k.hasFormat(p)||k.toggleFormat(p);k.hasFormat("code")||T(k,b,c);l&&T(l,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,l,k,p;0===e?[l,a]=a.splitText(f):[k,l,p]=a.splitText(e,f);k&&U(k,b);p&&(a=p);c.replace(l,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}
@@ -25,7 +25,7 @@ export:(a,b)=>{if(!B.$isQuoteNode(a))return null;a=b(a).split("\n");b=[];for(con
 (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:"**",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=`[${a.getTextContent()}](${a.getURL()})`;const d=a.getFirstChild();return 1===a.getChildrenSize()&&h.$isTextNode(d)?c(d,b):b},importRegExp:/(?:\[([^[]+)\])(?:\(([^()]+)\))/,regExp:/(?:\[([^[]+)\])(?:\(([^()]+)\))$/,replace:(a,b)=>{const [,c,d]=b;b=G.$createLinkNode(d);const e=h.$createTextNode(c);e.setFormat(a.getFormat());
-b.append(e);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){return ha(b)(a)};exports.$convertToMarkdownString=function(a=Z){return ba(a)()};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;
+b.append(e);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;exports.STRIKETHROUGH=ya;exports.TEXT_FORMAT_TRANSFORMERS=Da;exports.TEXT_MATCH_TRANSFORMERS=Ea;exports.TRANSFORMERS=Z;exports.UNORDERED_LIST=oa;
 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)&&!a.hasNodes(f.dependencies))throw Error("Minified Lexical error #79; visit https://lexical.dev/docs/error?code=79 for the full message or use the non-minified dev environment for full errors and additional helpful warnings.");return a.registerUpdateListener(({tags:f,dirtyLeaves:l,editorState:k,prevEditorState:p})=>
 {if(!f.has("historic")){var r=k.read(h.$getSelection);f=p.read(h.$getSelection);if(h.$isRangeSelection(f)&&h.$isRangeSelection(r)&&r.isCollapsed()){p=r.anchor.key;var y=r.anchor.offset,q=k._nodeMap.get(p);h.$isTextNode(q)&&l.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 g=c.element,n=m.getParent();if(h.$isRootOrShadowRoot(n)&&m.getFirstChild()===q&&(n=q.getTextContent()," "===n[w-1]))for(let {regExp:D,

package/MarkdownExport.d.ts

@@ -6,4 +6,5 @@
  *
  */
 import type { Transformer } from '@lexical/markdown';
-export declare function createMarkdownExport(transformers: Array<Transformer>): () => string;
+import type { ElementNode } from 'lexical';
+export declare function createMarkdownExport(transformers: Array<Transformer>): (node?: ElementNode) => string;

package/MarkdownImport.d.ts

@@ -6,4 +6,5 @@
  *
  */
 import type { Transformer } from '@lexical/markdown';
-export declare function createMarkdownImport(transformers: Array<Transformer>): (markdownString: string) => void;
+import { ElementNode } from 'lexical';
+export declare function createMarkdownImport(transformers: Array<Transformer>): (markdownString: string, node?: ElementNode) => void;

package/index.d.ts

@@ -7,12 +7,13 @@
  *
  */
 import type { ElementTransformer, TextFormatTransformer, TextMatchTransformer, Transformer } from './MarkdownTransformers';
+import type { ElementNode } from 'lexical';
 import { registerMarkdownShortcuts } from './MarkdownShortcuts';
 import { BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, CHECK_LIST, CODE, HEADING, HIGHLIGHT, INLINE_CODE, ITALIC_STAR, ITALIC_UNDERSCORE, LINK, ORDERED_LIST, QUOTE, STRIKETHROUGH, UNORDERED_LIST } from './MarkdownTransformers';
 declare const ELEMENT_TRANSFORMERS: Array<ElementTransformer>;
 declare const TEXT_FORMAT_TRANSFORMERS: Array<TextFormatTransformer>;
 declare const TEXT_MATCH_TRANSFORMERS: Array<TextMatchTransformer>;
 declare const TRANSFORMERS: Array<Transformer>;
-declare function $convertFromMarkdownString(markdown: string, transformers?: Array<Transformer>): void;
-declare function $convertToMarkdownString(transformers?: Array<Transformer>): string;
+declare function $convertFromMarkdownString(markdown: string, transformers?: Array<Transformer>, node?: ElementNode): void;
+declare function $convertToMarkdownString(transformers?: Array<Transformer>, node?: ElementNode): string;
 export { $convertFromMarkdownString, $convertToMarkdownString, BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, CHECK_LIST, CODE, ELEMENT_TRANSFORMERS, ElementTransformer, HEADING, HIGHLIGHT, INLINE_CODE, ITALIC_STAR, ITALIC_UNDERSCORE, LINK, ORDERED_LIST, QUOTE, registerMarkdownShortcuts, STRIKETHROUGH, TEXT_FORMAT_TRANSFORMERS, TEXT_MATCH_TRANSFORMERS, TextFormatTransformer, TextMatchTransformer, Transformer, TRANSFORMERS, UNORDERED_LIST, };

package/package.json

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

package/convertToMarkdown.d.ts

@@ -1,8 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-export declare function $convertToMarkdownString(): string;