@lexical/markdown 0.7.7 → 0.7.9

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 () => {
     const output = [];
     const children = 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,12 @@ 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 && /^(?=.*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);
+CAN_USE_DOM && /^(?=.*Chrome).*/i.test(navigator.userAgent);
+// export const canUseTextInputEvent: boolean = CAN_USE_DOM && 'TextEvent' in window && !documentMode;
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -243,86 +218,72 @@ function createMarkdownImport(transformers) {
     const linesLength = lines.length;
     const root = 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();
       }
     }
-
     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();
@@ -330,17 +291,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'));
@@ -350,157 +307,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
@@ -508,14 +441,12 @@ function createTextFormatTransformersIndex(textTransformers) {
     transformersByTag[tag] = transformer;
     const tagRegExp = tag.replace(/(\*|\^|\+)/g, '\\$1');
     openTagsRegExp.push(tagRegExp);
-
     if (IS_SAFARI || IS_IOS) {
       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,
@@ -532,31 +463,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);
@@ -566,131 +493,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);
@@ -698,62 +609,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, ({
@@ -762,13 +666,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;
-
       if (!editor.hasNodes(dependencies)) {
         {
           throw Error(`MarkdownShortcuts: missing dependency for transformer. Ensure node dependency is included in editor initial config.`);
@@ -776,19 +677,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,
@@ -799,35 +696,26 @@ 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);
     });
   });
@@ -840,7 +728,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);
@@ -848,17 +735,15 @@ 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 listItem = list.$createListItemNode(listType === 'check' ? match[3] === 'x' : undefined);
-
     if (list.$isListNode(previousNode) && previousNode.getListType() === listType) {
       previousNode.append(listItem);
       parentNode.remove();
@@ -867,33 +752,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' : ' '}] ` : '- ';
@@ -901,17 +780,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);
   },
@@ -928,21 +804,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);
@@ -950,7 +822,6 @@ const QUOTE = {
         return;
       }
     }
-
     const node = richText.$createQuoteNode();
     node.append(...children);
     parentNode.replace(node);
@@ -964,7 +835,6 @@ const CODE = {
     if (!code.$isCodeNode(node)) {
       return null;
     }
-
     const textContent = node.getTextContent();
     return '```' + (node.getLanguage() || '') + (textContent ? '\n' + textContent : '') + '\n' + '```';
   },
@@ -1006,6 +876,11 @@ const INLINE_CODE = {
   tag: '`',
   type: 'text-format'
 };
+const HIGHLIGHT = {
+  format: ['highlight'],
+  tag: '==',
+  type: 'text-format'
+};
 const BOLD_ITALIC_STAR = {
   format: ['bold', 'italic'],
   tag: '***',
@@ -1043,22 +918,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 {
@@ -1080,20 +955,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, ITALIC_STAR, ITALIC_UNDERSCORE, STRIKETHROUGH];
+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) {
   const importMarkdown = createMarkdownImport(transformers);
   return importMarkdown(markdown);
 }
-
 function $convertToMarkdownString(transformers = TRANSFORMERS) {
   const exportMarkdown = createMarkdownExport(transformers);
   return exportMarkdown();
@@ -1109,6 +983,7 @@ exports.CHECK_LIST = CHECK_LIST;
 exports.CODE = CODE;
 exports.ELEMENT_TRANSFORMERS = ELEMENT_TRANSFORMERS;
 exports.HEADING = HEADING;
+exports.HIGHLIGHT = HIGHLIGHT;
 exports.INLINE_CODE = INLINE_CODE;
 exports.ITALIC_STAR = ITALIC_STAR;
 exports.ITALIC_UNDERSCORE = ITALIC_UNDERSCORE;

package/LexicalMarkdown.prod.js

@@ -23,12 +23,12 @@ let W=a=>(b,c,d)=>{d=a(d);d.append(...c);b.replace(d);d.select(0,0)},X=a=>(b,c,d
 (e=k.getFirstChild(),A.$isListNode(e))){d.push(Y(e,b,c+1));continue}e=" ".repeat(4*c);var l=a.getListType();l="number"===l?`${a.getStart()+f}. `:"check"===l?`- [${k.getChecked()?"x":" "}] `:"- ";d.push(e+l+b(k));f++}return d.join("\n")},ja={dependencies:[C.HeadingNode],export:(a,b)=>{if(!C.$isHeadingNode(a))return null;const c=Number(a.getTag().slice(1));return"#".repeat(c)+" "+b(a)},regExp:/^(#{1,6})\s/,replace:W(a=>C.$createHeadingNode("h"+a[1].length)),type:"element"},ka={dependencies:[C.QuoteNode],
 export:(a,b)=>{if(!C.$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(),C.$isQuoteNode(c))){c.splice(c.getChildrenSize(),0,[h.$createLineBreakNode(),...b]);c.select(0,0);a.remove();return}c=C.$createQuoteNode();c.append(...b);a.replace(c);c.select(0,0)},type:"element"},la={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:W(a=>t.$createCodeNode(a?a[1]:void 0)),type:"element"},ma={dependencies:[A.ListNode,A.ListItemNode],export:(a,b)=>A.$isListNode(a)?Y(a,b,0):null,regExp:/^(\s*)[-*+]\s/,replace:X("bullet"),type:"element"},na={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"},oa={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"},pa={format:["code"],tag:"`",type:"text-format"},qa={format:["bold","italic"],tag:"***",type:"text-format"},ra={format:["bold","italic"],intraword:!1,tag:"___",type:"text-format"},ta={format:["bold"],tag:"**",type:"text-format"},ua={format:["bold"],intraword:!1,tag:"__",type:"text-format"},va={format:["strikethrough"],tag:"~~",type:"text-format"},wa={format:["italic"],tag:"*",type:"text-format"},xa={format:["italic"],
-intraword:!1,tag:"_",type:"text-format"},ya={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"},
-za=[ja,ka,la,ma,oa],Aa=[pa,qa,ra,ta,ua,wa,xa,va],Ba=[ya],Z=[...za,...Aa,...Ba];exports.$convertFromMarkdownString=function(a,b=Z){return fa(b)(a)};exports.$convertToMarkdownString=function(a=Z){return ba(a)()};exports.BOLD_ITALIC_STAR=qa;exports.BOLD_ITALIC_UNDERSCORE=ra;exports.BOLD_STAR=ta;exports.BOLD_UNDERSCORE=ua;exports.CHECK_LIST=na;exports.CODE=la;exports.ELEMENT_TRANSFORMERS=za;exports.HEADING=ja;exports.INLINE_CODE=pa;exports.ITALIC_STAR=wa;exports.ITALIC_UNDERSCORE=xa;exports.LINK=ya;
-exports.ORDERED_LIST=oa;exports.QUOTE=ka;exports.STRIKETHROUGH=va;exports.TEXT_FORMAT_TRANSFORMERS=Aa;exports.TEXT_MATCH_TRANSFORMERS=Ba;exports.TRANSFORMERS=Z;exports.UNORDERED_LIST=ma;
+b)=>A.$isListNode(a)?Y(a,b,0):null,regExp:/^(\s*)(\d{1,})\.\s/,replace:X("number"),type:"element"},pa={format:["code"],tag:"`",type:"text-format"},qa={format:["highlight"],tag:"==",type:"text-format"},ra={format:["bold","italic"],tag:"***",type:"text-format"},sa={format:["bold","italic"],intraword:!1,tag:"___",type:"text-format"},ua={format:["bold"],tag:"**",type:"text-format"},va={format:["bold"],intraword:!1,tag:"__",type:"text-format"},wa={format:["strikethrough"],tag:"~~",type:"text-format"},
+xa={format:["italic"],tag:"*",type:"text-format"},ya={format:["italic"],intraword:!1,tag:"_",type:"text-format"},za={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"},Aa=[ja,ka,la,ma,oa],Ba=[pa,ra,sa,ua,va,qa,xa,ya,wa],Ca=[za],Z=[...Aa,...Ba,...Ca];exports.$convertFromMarkdownString=function(a,b=Z){return fa(b)(a)};exports.$convertToMarkdownString=function(a=Z){return ba(a)()};exports.BOLD_ITALIC_STAR=ra;exports.BOLD_ITALIC_UNDERSCORE=sa;exports.BOLD_STAR=ua;exports.BOLD_UNDERSCORE=va;exports.CHECK_LIST=na;exports.CODE=la;exports.ELEMENT_TRANSFORMERS=Aa;exports.HEADING=ja;exports.HIGHLIGHT=qa;
+exports.INLINE_CODE=pa;exports.ITALIC_STAR=xa;exports.ITALIC_UNDERSCORE=ya;exports.LINK=za;exports.ORDERED_LIST=oa;exports.QUOTE=ka;exports.STRIKETHROUGH=wa;exports.TEXT_FORMAT_TRANSFORMERS=Ba;exports.TEXT_MATCH_TRANSFORMERS=Ca;exports.TRANSFORMERS=Z;exports.UNORDERED_LIST=ma;
 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,
-replace:E}of g)if((g=n.match(D))&&g[0].length===w){n=q.getNextSiblings();let [F,sa]=q.splitText(w);F.remove();n=sa?[sa,...n]:n;E(m,n,g,!1);m=!0;break b}m=!1}if(!m){b:{g=q.getTextContent();m=e[g[w-1]];if(null!=m){w<g.length&&(g=g.slice(0,w));for(x of m)if(m=g.match(x.regExp),null!==m){g=m.index||0;n=g+m[0].length;var v=void 0;0===g?[v]=q.splitText(n):[,v]=q.splitText(g,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:B}=
+replace:E}of g)if((g=n.match(D))&&g[0].length===w){n=q.getNextSiblings();let [F,ta]=q.splitText(w);F.remove();n=ta?[ta,...n]:n;E(m,n,g,!1);m=!0;break b}m=!1}if(!m){b:{g=q.getTextContent();m=e[g[w-1]];if(null!=m){w<g.length&&(g=g.slice(0,w));for(x of m)if(m=g.match(x.regExp),null!==m){g=m.index||0;n=g+m[0].length;var v=void 0;0===g?[v]=q.splitText(n):[,v]=q.splitText(g,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:B}=
 D;x=B.length;let E=w-x+1;if(!(1<x&&!V(n,E,B,0,x)||" "===n[E-1])&&(v=n[w+1],!1!==D.intraword||!v||J.test(v))){m=v=q;g=U(n,E,B);for(var z=m;0>g&&(z=z.getPreviousSibling())&&!h.$isLineBreakNode(z);)h.$isTextNode(z)&&(g=z.getTextContent(),m=z,g=U(g,g.length,B));if(!(0>g||m===v&&g+x===E||(B=m.getTextContent(),0<g&&B[g-1]===u||(z=B[g-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:B;m.setTextContent(n.slice(0,g)+n.slice(g+x));n=h.$getSelection();
 u=h.$createRangeSelection();h.$setSelection(u);w=w-x*(m===v?2:1)+1;u.anchor.set(m.__key,g,"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);h.$isRangeSelection(n)&&(u.format=n.format);break b}}}}}}}})}}})}

package/MarkdownTransformers.d.ts

@@ -36,6 +36,7 @@ export declare const UNORDERED_LIST: ElementTransformer;
 export declare const CHECK_LIST: ElementTransformer;
 export declare const ORDERED_LIST: ElementTransformer;
 export declare const INLINE_CODE: TextFormatTransformer;
+export declare const HIGHLIGHT: TextFormatTransformer;
 export declare const BOLD_ITALIC_STAR: TextFormatTransformer;
 export declare const BOLD_ITALIC_UNDERSCORE: TextFormatTransformer;
 export declare const BOLD_STAR: TextFormatTransformer;

package/index.d.ts

@@ -8,11 +8,11 @@
  */
 import type { ElementTransformer, TextFormatTransformer, TextMatchTransformer, Transformer } from './MarkdownTransformers';
 import { registerMarkdownShortcuts } from './MarkdownShortcuts';
-import { BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, CHECK_LIST, CODE, HEADING, INLINE_CODE, ITALIC_STAR, ITALIC_UNDERSCORE, LINK, ORDERED_LIST, QUOTE, STRIKETHROUGH, UNORDERED_LIST } from './MarkdownTransformers';
+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;
-export { $convertFromMarkdownString, $convertToMarkdownString, BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, CHECK_LIST, CODE, ELEMENT_TRANSFORMERS, ElementTransformer, HEADING, INLINE_CODE, ITALIC_STAR, ITALIC_UNDERSCORE, LINK, ORDERED_LIST, QUOTE, registerMarkdownShortcuts, STRIKETHROUGH, TEXT_FORMAT_TRANSFORMERS, TEXT_MATCH_TRANSFORMERS, TextFormatTransformer, TextMatchTransformer, Transformer, TRANSFORMERS, UNORDERED_LIST, };
+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.7.7",
+  "version": "0.7.9",
   "main": "LexicalMarkdown.js",
   "peerDependencies": {
-    "lexical": "0.7.7"
+    "lexical": "0.7.9"
   },
   "dependencies": {
-    "@lexical/utils": "0.7.7",
-    "@lexical/code": "0.7.7",
-    "@lexical/text": "0.7.7",
-    "@lexical/rich-text": "0.7.7",
-    "@lexical/list": "0.7.7",
-    "@lexical/link": "0.7.7"
+    "@lexical/utils": "0.7.9",
+    "@lexical/code": "0.7.9",
+    "@lexical/text": "0.7.9",
+    "@lexical/rich-text": "0.7.9",
+    "@lexical/list": "0.7.9",
+    "@lexical/link": "0.7.9"
   },
   "repository": {
     "type": "git",