@lexical/markdown 0.1.17

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LexicalMarkdown.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ *
+ */
+
+import type {DecoratorNode, LexicalEditor} from 'lexical';
+
+export function registerMarkdownShortcuts<T>(
+  editor: LexicalEditor,
+  createHorizontalRuleNode: () => DecoratorNode<T>,
+): () => void;
+export function $convertFromMarkdownString(
+  markdownString: string,
+  editor: LexicalEditor,
+): void;

package/LexicalMarkdown.dev.js

@@ -0,0 +1,893 @@
+/**
+ * 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.
+ */
+'use strict';
+
+var lexical = require('lexical');
+var code = require('@lexical/code');
+var list = require('@lexical/list');
+var link = require('@lexical/link');
+var richText = require('@lexical/rich-text');
+var text = require('@lexical/text');
+
+/**
+ * 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.
+ *
+ * 
+ */
+/*
+   How to add a new syntax to capture and transform.
+   1. Create a new enumeration by adding to AutoFormatKind.
+   2. Add a new criteria with a regEx pattern. See markdownStrikethrough as an example.
+   3. Add your block criteria (e.g. '# ') to allMarkdownCriteria or 
+      your text criteria (e.g. *MyItalic*) to allMarkdownCriteriaForTextNodes.
+   4. Add your Lexical block specific transforming code here: transformTextNodeForText.   
+      Add your Lexical text specific transforming code here: transformTextNodeForText.   
+   */
+// The trigger state helps to capture EditorState information
+// from the prior and current EditorState.
+// This is then used to determined if an auto format has been triggered.
+
+// Eventually we need to support multiple trigger string's including newlines.
+const SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES = '\u0004'; // Select an unused unicode character to separate text and non-text nodes.
+
+const SEPARATOR_LENGTH = SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES.length;
+const spaceTrigger = {
+  triggerKind: 'space_trigger',
+  triggerString: '\u0020'
+}; // TODO: add support for ``` + carriage return either inside or not inside code block. Should toggle between.
+// const codeBlockTrigger : AutoFormatTrigger = {
+//     triggerKind: 'codeBlock_trigger',
+//     triggerString: '```', // + new paragraph element or new code block element.
+// };
+
+const triggers = [spaceTrigger
+/*, codeBlockTrigger*/
+]; // Todo: speed up performance by having non-capture group variations of the regex.
+
+const autoFormatBase = {
+  autoFormatKind: null,
+  regEx: /(?:)/,
+  regExForAutoFormatting: /(?:)/,
+  requiresParagraphStart: false
+};
+const paragraphStartBase = { ...autoFormatBase,
+  requiresParagraphStart: true
+};
+const markdownHeader1 = { ...paragraphStartBase,
+  autoFormatKind: 'paragraphH1',
+  regEx: /^(?:#)/,
+  regExForAutoFormatting: /^(?:# )/
+};
+const markdownHeader2 = { ...paragraphStartBase,
+  autoFormatKind: 'paragraphH2',
+  regEx: /^(?:##)/,
+  regExForAutoFormatting: /^(?:## )/
+};
+const markdownHeader3 = { ...paragraphStartBase,
+  autoFormatKind: 'paragraphH2',
+  regEx: /^(?:###)/,
+  regExForAutoFormatting: /^(?:### )/
+};
+const markdownBlockQuote = { ...paragraphStartBase,
+  autoFormatKind: 'paragraphBlockQuote',
+  regEx: /^(?:>)/,
+  regExForAutoFormatting: /^(?:> )/
+};
+const markdownUnorderedListDash = { ...paragraphStartBase,
+  autoFormatKind: 'paragraphUnorderedList',
+  regEx: /^(?:- )/,
+  regExForAutoFormatting: /^(?:- )/
+};
+const markdownUnorderedListAsterisk = { ...paragraphStartBase,
+  autoFormatKind: 'paragraphUnorderedList',
+  regEx: /^(?:\* )/,
+  regExForAutoFormatting: /^(?:\* )/
+};
+const markdownCodeBlock = { ...paragraphStartBase,
+  autoFormatKind: 'paragraphCodeBlock',
+  regEx: /^(```)$/,
+  regExForAutoFormatting: /^(```)([a-z]*)( )/
+};
+const markdownOrderedList = { ...paragraphStartBase,
+  autoFormatKind: 'paragraphOrderedList',
+  regEx: /^(\d+)\.\s/,
+  regExForAutoFormatting: /^(\d+)\.\s/
+};
+const markdownHorizontalRule = { ...paragraphStartBase,
+  autoFormatKind: 'horizontalRule',
+  regEx: /^(?:\*\*\*)$/,
+  regExForAutoFormatting: /^(?:\*\*\* )/
+};
+const markdownHorizontalRuleUsingDashes = { ...paragraphStartBase,
+  autoFormatKind: 'horizontalRule',
+  regEx: /^(?:---)$/,
+  regExForAutoFormatting: /^(?:--- )/
+};
+const markdownItalic = { ...autoFormatBase,
+  autoFormatKind: 'italic',
+  regEx: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*)/,
+  regExForAutoFormatting: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*)(\s)$/
+};
+const markdownBold = { ...autoFormatBase,
+  autoFormatKind: 'bold',
+  regEx: /(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)/,
+  regExForAutoFormatting: /(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)(\s)$/
+};
+const markdownBoldWithUnderlines = { ...autoFormatBase,
+  autoFormatKind: 'bold',
+  regEx: /(__)(\s*)([^__]*)(\s*)(__)/,
+  regExForAutoFormatting: /(__)(\s*)([^__]*)(\s*)(__)(\s)$/
+};
+const markdownBoldItalic = { ...autoFormatBase,
+  autoFormatKind: 'bold_italic',
+  regEx: /(\*\*\*)(\s*\b)([^\*\*\*]*)(\b\s*)(\*\*\*)/,
+  regExForAutoFormatting: /(\*\*\*)(\s*\b)([^\*\*\*]*)(\b\s*)(\*\*\*)(\s)$/
+}; // Markdown does not support underline, but we can allow folks to use
+// the HTML tags for underline.
+
+const fakeMarkdownUnderline = { ...autoFormatBase,
+  autoFormatKind: 'underline',
+  regEx: /(\<u\>)(\s*\b)([^\<]*)(\b\s*)(\<\/u\>)/,
+  regExForAutoFormatting: /(\<u\>)(\s*\b)([^\<]*)(\b\s*)(\<\/u\>)(\s)$/
+};
+const markdownStrikethrough = { ...autoFormatBase,
+  autoFormatKind: 'strikethrough',
+  regEx: /(~~)(\s*\b)([^~~]*)(\b\s*)(~~)/,
+  regExForAutoFormatting: /(~~)(\s*\b)([^~~]*)(\b\s*)(~~)(\s)$/
+};
+const markdownLink = { ...autoFormatBase,
+  autoFormatKind: 'link',
+  regEx: /(\[)(.+)(\]\()([^ ]+)(?: \"(?:.+)\")?(\))/,
+  regExForAutoFormatting: /(\[)(.+)(\]\()([^ ]+)(?: \"(?:.+)\")?(\))(\s)$/
+};
+const allMarkdownCriteriaForTextNodes = [markdownBoldItalic, markdownItalic, markdownBold, markdownBoldWithUnderlines, fakeMarkdownUnderline, markdownStrikethrough, markdownLink];
+const allMarkdownCriteria = [markdownHeader1, markdownHeader2, markdownHeader3, markdownBlockQuote, markdownUnorderedListDash, markdownUnorderedListAsterisk, markdownOrderedList, markdownCodeBlock, markdownHorizontalRule, markdownHorizontalRuleUsingDashes, ...allMarkdownCriteriaForTextNodes];
+function getInitialScanningContext(editor, isAutoFormatting, textNodeWithOffset, triggerState) {
+  return {
+    editor,
+    isAutoFormatting,
+    joinedText: null,
+    markdownCriteria: {
+      autoFormatKind: 'noTransformation',
+      regEx: /(?:)/,
+      // Empty reg ex.
+      regExForAutoFormatting: /(?:)/,
+      // Empty reg ex.
+      requiresParagraphStart: null
+    },
+    patternMatchResults: {
+      regExCaptureGroups: []
+    },
+    textNodeWithOffset,
+    triggerState
+  };
+}
+function resetScanningContext(scanningContext) {
+  scanningContext.joinedText = '';
+  scanningContext.markdownCriteria = {
+    autoFormatKind: 'noTransformation',
+    regEx: /(?:)/,
+    // Empty reg ex.
+    regExForAutoFormatting: /(?:)/,
+    // Empty reg ex.
+    requiresParagraphStart: null
+  };
+  scanningContext.patternMatchResults = {
+    regExCaptureGroups: []
+  };
+  scanningContext.triggerState = null;
+  scanningContext.textNodeWithOffset = null;
+  return scanningContext;
+}
+
+function getPatternMatchResultsWithRegEx(textToSearch, matchMustAppearAtStartOfString, matchMustAppearAtEndOfString, regEx) {
+  const patternMatchResults = {
+    regExCaptureGroups: []
+  };
+  const regExMatches = textToSearch.match(regEx);
+
+  if (regExMatches !== null && regExMatches.length > 0 && (matchMustAppearAtStartOfString === false || regExMatches.index === 0) && (matchMustAppearAtEndOfString === false || regExMatches.index + regExMatches[0].length === textToSearch.length)) {
+    const captureGroupsCount = regExMatches.length;
+    let runningLength = regExMatches.index;
+
+    for (let captureGroupIndex = 0; captureGroupIndex < captureGroupsCount; captureGroupIndex++) {
+      const textContent = regExMatches[captureGroupIndex];
+      patternMatchResults.regExCaptureGroups.push({
+        offsetInParent: runningLength,
+        text: textContent
+      }); // The 0th capture group is special in that it's text contents is
+      // a join of all subsequent capture groups. So, skip this group
+      // when calculating the runningLength.
+
+      if (captureGroupIndex > 0) {
+        runningLength += textContent.length;
+      }
+    }
+
+    return patternMatchResults;
+  }
+
+  return null;
+}
+
+function getTextNodeWithOffsetOrThrow(scanningContext) {
+  const textNodeWithOffset = scanningContext.textNodeWithOffset;
+
+  if (textNodeWithOffset == null) {
+    {
+      throw Error(`Expect to have a text node with offset.`);
+    }
+  }
+
+  return textNodeWithOffset;
+}
+function getPatternMatchResultsForParagraphs(markdownCriteria, scanningContext) {
+  const textNodeWithOffset = getTextNodeWithOffsetOrThrow(scanningContext); // At start of paragraph.
+
+  if (textNodeWithOffset.node.getPreviousSibling() === null) {
+    const textToSearch = textNodeWithOffset.node.getTextContent();
+    return getPatternMatchResultsWithRegEx(textToSearch, true, false, markdownCriteria.regExForAutoFormatting);
+  }
+
+  return null;
+}
+function getPatternMatchResultsForText(markdownCriteria, scanningContext) {
+  if (scanningContext.joinedText == null) {
+    const parentNode = getParent(scanningContext);
+
+    if (lexical.$isElementNode(parentNode)) {
+      if (scanningContext.joinedText == null) {
+        // Lazy calculate the text to search.
+        scanningContext.joinedText = text.$joinTextNodesInElementNode(parentNode, SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES, getTextNodeWithOffsetOrThrow(scanningContext));
+      }
+    } else {
+      {
+        throw Error(`Expected node ${parentNode.__key} to to be a ElementNode.`);
+      }
+    }
+  }
+
+  return getPatternMatchResultsWithRegEx(scanningContext.joinedText, false, true, markdownCriteria.regExForAutoFormatting);
+}
+
+function getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNode) {
+  let newNode = null;
+  const children = element.getChildren();
+  const markdownCriteria = scanningContext.markdownCriteria;
+  const patternMatchResults = scanningContext.patternMatchResults;
+
+  if (markdownCriteria.autoFormatKind != null) {
+    switch (markdownCriteria.autoFormatKind) {
+      case 'paragraphH1':
+        {
+          newNode = richText.$createHeadingNode('h1');
+          newNode.append(...children);
+          return newNode;
+        }
+
+      case 'paragraphH2':
+        {
+          newNode = richText.$createHeadingNode('h2');
+          newNode.append(...children);
+          return newNode;
+        }
+
+      case 'paragraphH3':
+        {
+          newNode = richText.$createHeadingNode('h3');
+          newNode.append(...children);
+          return newNode;
+        }
+
+      case 'paragraphBlockQuote':
+        {
+          newNode = richText.$createQuoteNode();
+          newNode.append(...children);
+          return newNode;
+        }
+
+      case 'paragraphUnorderedList':
+        {
+          newNode = list.$createListNode('ul');
+          const listItem = list.$createListItemNode();
+          listItem.append(...children);
+          newNode.append(listItem);
+          return newNode;
+        }
+
+      case 'paragraphOrderedList':
+        {
+          const startAsString = patternMatchResults.regExCaptureGroups.length > 1 ? patternMatchResults.regExCaptureGroups[patternMatchResults.regExCaptureGroups.length - 1].text : '1';
+          const start = parseInt(startAsString, 10);
+          newNode = list.$createListNode('ol', start);
+          const listItem = list.$createListItemNode();
+          listItem.append(...children);
+          newNode.append(listItem);
+          return newNode;
+        }
+
+      case 'paragraphCodeBlock':
+        {
+          // Toggle code and paragraph nodes.
+          if (scanningContext.triggerState != null && scanningContext.triggerState.isCodeBlock) {
+            newNode = lexical.$createParagraphNode();
+          } else {
+            newNode = code.$createCodeNode();
+            const codingLanguage = patternMatchResults.regExCaptureGroups.length >= 3 ? patternMatchResults.regExCaptureGroups[2].text : null;
+
+            if (codingLanguage != null && codingLanguage.length > 0) {
+              newNode.setLanguage(codingLanguage);
+            }
+          }
+
+          newNode.append(...children);
+          return newNode;
+        }
+
+      case 'horizontalRule':
+        {
+          // return null for newNode. Insert the HR here.
+          const horizontalRuleNode = createHorizontalRuleNode();
+          element.insertBefore(horizontalRuleNode);
+          break;
+        }
+    }
+  }
+
+  return newNode;
+}
+
+function transformTextNodeForParagraphs(scanningContext, createHorizontalRuleNode) {
+  const textNodeWithOffset = getTextNodeWithOffsetOrThrow(scanningContext);
+  const element = textNodeWithOffset.node.getParentOrThrow();
+  const text = scanningContext.patternMatchResults.regExCaptureGroups[0].text; // Remove the text which we matched.
+
+  const textNode = textNodeWithOffset.node.spliceText(0, text.length, '', true);
+
+  if (textNode.getTextContent() === '') {
+    textNode.selectPrevious();
+    textNode.remove();
+  } // Transform the current element kind to the new element kind.
+
+
+  const elementNode = getNewNodeForCriteria(scanningContext, element, createHorizontalRuleNode);
+
+  if (elementNode !== null) {
+    element.replace(elementNode);
+  }
+}
+function transformTextNodeForText(scanningContext) {
+  const markdownCriteria = scanningContext.markdownCriteria;
+
+  if (markdownCriteria.autoFormatKind != null) {
+    const formatting = getTextFormatType(markdownCriteria.autoFormatKind);
+
+    if (formatting != null) {
+      transformTextNodeWithFormatting(formatting, scanningContext);
+      return;
+    }
+
+    if (markdownCriteria.autoFormatKind === 'link') {
+      transformTextNodeWithLink(scanningContext);
+    }
+  }
+}
+
+function transformTextNodeWithFormatting(formatting, scanningContext) {
+  const patternMatchResults = scanningContext.patternMatchResults;
+  const groupCount = patternMatchResults.regExCaptureGroups.length;
+
+  if (groupCount !== 7) {
+    // For BIUS and similar formats which have a pattern + text + pattern:
+    // given '*italic* ' below are the capture groups by index:
+    // 0. '*italic* '
+    // 1. '*'
+    // 2. whitespace  // typically this is "".
+    // 3. 'italic'
+    // 4. whitespace  // typicallly this is "".
+    // 5. '*'
+    // 6. ' '
+    return;
+  } // Remove unwanted text in reg ex pattern.
+  // Remove group 5.
+
+
+  removeTextByCaptureGroups(5, 5, scanningContext); // Remove group 1.
+
+  removeTextByCaptureGroups(1, 1, scanningContext); // Apply the formatting.
+
+  formatTextInCaptureGroupIndex(formatting, 3, scanningContext); // Place caret at end of final capture group.
+
+  selectAfterFinalCaptureGroup(scanningContext);
+}
+
+function transformTextNodeWithLink(scanningContext) {
+  const patternMatchResults = scanningContext.patternMatchResults;
+  const regExCaptureGroups = patternMatchResults.regExCaptureGroups;
+  const groupCount = regExCaptureGroups.length;
+
+  if (groupCount !== 7) {
+    // For links and similar formats which have: pattern + text + pattern + pattern2 text2 + pattern2:
+    // Given '[title](url) ', below are the capture groups by index:
+    // 0. '[title](url) '
+    // 1. '['
+    // 2. 'title'
+    // 3. ']('
+    // 4. 'url'
+    // 5. ')'
+    // 6. ' '
+    return;
+  }
+
+  const title = regExCaptureGroups[2].text;
+  const url = regExCaptureGroups[4].text;
+
+  if (title.length === 0 || url.length === 0) {
+    return;
+  } // Remove the initial pattern through to the final pattern.
+
+
+  removeTextByCaptureGroups(1, 5, scanningContext);
+  insertTextPriorToCaptureGroup(1, // Insert at the beginning of the meaningful capture groups, namely index 1. Index 0 refers to the whole matched string.
+  title, scanningContext);
+  const newSelectionForLink = createSelectionWithCaptureGroups(1, 1, false, true, scanningContext);
+
+  if (newSelectionForLink == null) {
+    return;
+  }
+
+  lexical.$setSelection(newSelectionForLink);
+  scanningContext.editor.dispatchCommand(link.TOGGLE_LINK_COMMAND, url); // Place caret at end of final capture group.
+
+  selectAfterFinalCaptureGroup(scanningContext);
+} // Below are lower level helper functions.
+
+
+function getParent(scanningContext) {
+  return getTextNodeWithOffsetOrThrow(scanningContext).node.getParentOrThrow();
+}
+
+function getJoinedTextLength(patternMatchResults) {
+  const groupCount = patternMatchResults.regExCaptureGroups.length;
+
+  if (groupCount < 2) {
+    // Ignore capture group 0, as regEx defaults the 0th one to the entire matched string.
+    return 0;
+  }
+
+  const lastGroupIndex = groupCount - 1;
+  return patternMatchResults.regExCaptureGroups[lastGroupIndex].offsetInParent + patternMatchResults.regExCaptureGroups[lastGroupIndex].text.length;
+}
+
+function getTextFormatType(autoFormatKind) {
+  switch (autoFormatKind) {
+    case 'italic':
+    case 'bold':
+    case 'underline':
+    case 'strikethrough':
+      return [autoFormatKind];
+
+    case 'bold_italic':
+      {
+        return ['bold', 'italic'];
+      }
+  }
+
+  return null;
+}
+
+function createSelectionWithCaptureGroups(anchorCaptureGroupIndex, focusCaptureGroupIndex, startAtEndOfAnchor, finishAtEndOfFocus, scanningContext) {
+  const patternMatchResults = scanningContext.patternMatchResults;
+  const regExCaptureGroups = patternMatchResults.regExCaptureGroups;
+  const regExCaptureGroupsCount = regExCaptureGroups.length;
+
+  if (anchorCaptureGroupIndex >= regExCaptureGroupsCount || focusCaptureGroupIndex >= regExCaptureGroupsCount) {
+    return null;
+  }
+
+  const parentElementNode = getParent(scanningContext);
+  const joinedTextLength = getJoinedTextLength(patternMatchResults);
+  const anchorCaptureGroupDetail = regExCaptureGroups[anchorCaptureGroupIndex];
+  const focusCaptureGroupDetail = regExCaptureGroups[focusCaptureGroupIndex];
+  const anchorLocation = startAtEndOfAnchor ? anchorCaptureGroupDetail.offsetInParent + anchorCaptureGroupDetail.text.length : anchorCaptureGroupDetail.offsetInParent;
+  const focusLocation = finishAtEndOfFocus ? focusCaptureGroupDetail.offsetInParent + focusCaptureGroupDetail.text.length : focusCaptureGroupDetail.offsetInParent;
+  const anchorTextNodeWithOffset = text.$findNodeWithOffsetFromJoinedText(anchorLocation, joinedTextLength, SEPARATOR_LENGTH, parentElementNode);
+  const focusTextNodeWithOffset = text.$findNodeWithOffsetFromJoinedText(focusLocation, joinedTextLength, SEPARATOR_LENGTH, parentElementNode);
+
+  if (anchorTextNodeWithOffset == null || focusTextNodeWithOffset == null) {
+    return null;
+  }
+
+  const selection = lexical.$createRangeSelection();
+  selection.anchor.set(anchorTextNodeWithOffset.node.getKey(), anchorTextNodeWithOffset.offset, 'text');
+  selection.focus.set(focusTextNodeWithOffset.node.getKey(), focusTextNodeWithOffset.offset, 'text');
+  return selection;
+}
+
+function removeTextByCaptureGroups(anchorCaptureGroupIndex, focusCaptureGroupIndex, scanningContext) {
+  const patternMatchResults = scanningContext.patternMatchResults;
+  const regExCaptureGroups = patternMatchResults.regExCaptureGroups;
+  const newSelection = createSelectionWithCaptureGroups(anchorCaptureGroupIndex, focusCaptureGroupIndex, false, true, scanningContext);
+
+  if (newSelection != null) {
+    lexical.$setSelection(newSelection);
+    const currentSelection = lexical.$getSelection();
+
+    if (currentSelection != null && lexical.$isRangeSelection(currentSelection) && currentSelection.isCollapsed() === false) {
+      currentSelection.removeText(); // Shift all group offsets and clear out group text.
+
+      let runningLength = 0;
+      const groupCount = regExCaptureGroups.length;
+
+      for (let i = anchorCaptureGroupIndex; i < groupCount; i++) {
+        const captureGroupDetail = regExCaptureGroups[i];
+
+        if (i > anchorCaptureGroupIndex) {
+          captureGroupDetail.offsetInParent -= runningLength;
+        }
+
+        if (i <= focusCaptureGroupIndex) {
+          runningLength += captureGroupDetail.text.length;
+          captureGroupDetail.text = '';
+        }
+      }
+    }
+  }
+}
+
+function insertTextPriorToCaptureGroup(captureGroupIndex, text, scanningContext) {
+  const patternMatchResults = scanningContext.patternMatchResults;
+  const regExCaptureGroups = patternMatchResults.regExCaptureGroups;
+  const regExCaptureGroupsCount = regExCaptureGroups.length;
+
+  if (captureGroupIndex >= regExCaptureGroupsCount) {
+    return;
+  }
+
+  const captureGroupDetail = regExCaptureGroups[captureGroupIndex];
+  const newCaptureGroupDetail = {
+    offsetInParent: captureGroupDetail.offsetInParent,
+    text
+  };
+  const newSelection = createSelectionWithCaptureGroups(captureGroupIndex, captureGroupIndex, false, false, scanningContext);
+
+  if (newSelection != null) {
+    lexical.$setSelection(newSelection);
+    const currentSelection = lexical.$getSelection();
+
+    if (currentSelection != null && lexical.$isRangeSelection(currentSelection) && currentSelection.isCollapsed()) {
+      currentSelection.insertText(newCaptureGroupDetail.text); // Update the capture groups.
+
+      regExCaptureGroups.splice(captureGroupIndex, 0, newCaptureGroupDetail);
+      const textLength = newCaptureGroupDetail.text.length;
+      const newGroupCount = regExCaptureGroups.length;
+
+      for (let i = captureGroupIndex + 1; i < newGroupCount; i++) {
+        const currentCaptureGroupDetail = regExCaptureGroups[i];
+        currentCaptureGroupDetail.offsetInParent += textLength;
+      }
+    }
+  }
+}
+
+function formatTextInCaptureGroupIndex(formatTypes, captureGroupIndex, scanningContext) {
+  const patternMatchResults = scanningContext.patternMatchResults;
+  const regExCaptureGroups = patternMatchResults.regExCaptureGroups;
+  const regExCaptureGroupsCount = regExCaptureGroups.length;
+
+  if (!(captureGroupIndex < regExCaptureGroupsCount)) {
+    throw Error(`The capture group count in the RegEx does match the actual capture group count.`);
+  }
+
+  const captureGroupDetail = regExCaptureGroups[captureGroupIndex];
+
+  if (captureGroupDetail.text.length === 0) {
+    return;
+  }
+
+  const newSelection = createSelectionWithCaptureGroups(captureGroupIndex, captureGroupIndex, false, true, scanningContext);
+
+  if (newSelection != null) {
+    lexical.$setSelection(newSelection);
+    const currentSelection = lexical.$getSelection();
+
+    if (lexical.$isRangeSelection(currentSelection)) {
+      for (let i = 0; i < formatTypes.length; i++) {
+        currentSelection.formatText(formatTypes[i]);
+      }
+    }
+  }
+} // Place caret at end of final capture group.
+
+
+function selectAfterFinalCaptureGroup(scanningContext) {
+  const patternMatchResults = scanningContext.patternMatchResults;
+  const groupCount = patternMatchResults.regExCaptureGroups.length;
+
+  if (groupCount < 2) {
+    // Ignore capture group 0, as regEx defaults the 0th one to the entire matched string.
+    return;
+  }
+
+  const lastGroupIndex = groupCount - 1;
+  const newSelection = createSelectionWithCaptureGroups(lastGroupIndex, lastGroupIndex, true, true, scanningContext);
+
+  if (newSelection != null) {
+    lexical.$setSelection(newSelection);
+  }
+}
+
+/**
+ * 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.
+ *
+ * 
+ */
+function getAllTriggers() {
+  return triggers;
+}
+function getAllMarkdownCriteriaForTextNodes() {
+  return allMarkdownCriteriaForTextNodes;
+}
+function getAllMarkdownCriteria() {
+  return allMarkdownCriteria;
+}
+function transformTextNodeForMarkdownCriteria(scanningContext, createHorizontalRuleNode) {
+  if (scanningContext.markdownCriteria.requiresParagraphStart === true) {
+    transformTextNodeForParagraphs(scanningContext, createHorizontalRuleNode);
+  } else {
+    transformTextNodeForText(scanningContext);
+  }
+}
+
+function getPatternMatchResultsForCriteria(markdownCriteria, scanningContext) {
+  if (markdownCriteria.requiresParagraphStart === true) {
+    return getPatternMatchResultsForParagraphs(markdownCriteria, scanningContext);
+  }
+
+  return getPatternMatchResultsForText(markdownCriteria, scanningContext);
+}
+
+function getTextNodeForAutoFormatting(selection) {
+  if (!lexical.$isRangeSelection(selection)) {
+    return null;
+  }
+
+  const node = selection.anchor.getNode();
+
+  if (!lexical.$isTextNode(node)) {
+    return null;
+  }
+
+  return {
+    node,
+    offset: selection.anchor.offset
+  };
+}
+
+function updateAutoFormatting(editor, scanningContext, createHorizontalRuleNode) {
+  editor.update(() => {
+    transformTextNodeForMarkdownCriteria(scanningContext, createHorizontalRuleNode);
+  }, {
+    tag: 'history-push'
+  });
+}
+
+function getCriteriaWithPatternMatchResults(markdownCriteriaArray, scanningContext) {
+  const currentTriggerState = scanningContext.triggerState;
+  const count = markdownCriteriaArray.length;
+
+  for (let i = 0; i < count; i++) {
+    const markdownCriteria = markdownCriteriaArray[i]; // Skip code block nodes, unless the autoFormatKind calls for toggling the code block.
+
+    if (currentTriggerState != null && currentTriggerState.isCodeBlock === false || markdownCriteria.autoFormatKind === 'paragraphCodeBlock') {
+      const patternMatchResults = getPatternMatchResultsForCriteria(markdownCriteria, scanningContext);
+
+      if (patternMatchResults != null) {
+        return {
+          markdownCriteria,
+          patternMatchResults
+        };
+      }
+    }
+  }
+
+  return {
+    markdownCriteria: null,
+    patternMatchResults: null
+  };
+}
+
+function findScanningContextWithValidMatch(editor, currentTriggerState) {
+  let scanningContext = null;
+  editor.getEditorState().read(() => {
+    const textNodeWithOffset = getTextNodeForAutoFormatting(lexical.$getSelection());
+
+    if (textNodeWithOffset === null) {
+      return;
+    } // Please see the declaration of ScanningContext for a detailed explanation.
+
+
+    const initialScanningContext = getInitialScanningContext(editor, true, textNodeWithOffset, currentTriggerState);
+    const criteriaWithPatternMatchResults = getCriteriaWithPatternMatchResults( // Do not apply paragraph node changes like blockQuote or H1 to listNodes. Also, do not attempt to transform a list into a list using * or -.
+    currentTriggerState.isParentAListItemNode === false ? getAllMarkdownCriteria() : getAllMarkdownCriteriaForTextNodes(), initialScanningContext);
+
+    if (criteriaWithPatternMatchResults.markdownCriteria === null || criteriaWithPatternMatchResults.patternMatchResults === null) {
+      return;
+    }
+
+    scanningContext = initialScanningContext; // Lazy fill-in the particular format criteria and any matching result information.
+
+    scanningContext.markdownCriteria = criteriaWithPatternMatchResults.markdownCriteria;
+    scanningContext.patternMatchResults = criteriaWithPatternMatchResults.patternMatchResults;
+  });
+  return scanningContext;
+}
+
+function getTriggerState(editorState) {
+  let criteria = null;
+  editorState.read(() => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection) || !selection.isCollapsed()) {
+      return;
+    }
+
+    const node = selection.anchor.getNode();
+    const parentNode = node.getParent();
+    const isParentAListItemNode = list.$isListItemNode(parentNode);
+    const hasParentNode = parentNode !== null;
+    criteria = {
+      anchorOffset: selection.anchor.offset,
+      hasParentNode,
+      isCodeBlock: code.$isCodeNode(node),
+      isParentAListItemNode,
+      isSelectionCollapsed: true,
+      isSimpleText: lexical.$isTextNode(node) && node.isSimpleText(),
+      nodeKey: node.getKey(),
+      textContent: node.getTextContent()
+    };
+  });
+  return criteria;
+}
+function findScanningContext(editor, currentTriggerState, priorTriggerState) {
+  if (currentTriggerState == null || priorTriggerState == null) {
+    return null;
+  }
+
+  const triggerArray = getAllTriggers();
+  const triggerCount = triggers.length;
+
+  for (let ti = 0; ti < triggerCount; ti++) {
+    const triggerString = triggerArray[ti].triggerString; // The below checks needs to execute relativey quickly, so perform the light-weight ones first.
+    // The substr check is a quick way to avoid autoformat parsing in that it looks for the autoformat
+    // trigger which is the trigger string (" ").
+
+    const triggerStringLength = triggerString.length;
+    const currentTextContentLength = currentTriggerState.textContent.length;
+    const triggerOffset = currentTriggerState.anchorOffset - triggerStringLength;
+
+    if ((currentTriggerState.hasParentNode === true && currentTriggerState.isSimpleText && currentTriggerState.isSelectionCollapsed && currentTriggerState.nodeKey === priorTriggerState.nodeKey && currentTriggerState.anchorOffset !== priorTriggerState.anchorOffset && triggerOffset >= 0 && triggerOffset + triggerStringLength <= currentTextContentLength && currentTriggerState.textContent.substr(triggerOffset, triggerStringLength) === triggerString && // Some code differentiation needed if trigger kind is not a simple space character.
+    currentTriggerState.textContent !== priorTriggerState.textContent) === false) {
+      return null;
+    }
+  }
+
+  return findScanningContextWithValidMatch(editor, currentTriggerState);
+}
+
+/**
+ * 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.
+ *
+ * 
+ */
+function convertStringToLexical(text, editor) {
+  const nodes = text.split('\n').map(splitText => lexical.$createParagraphNode().append(lexical.$createTextNode(splitText)));
+  const root = lexical.$getRoot();
+  root.clear();
+  root.append(...nodes);
+}
+
+function convertElementNodeContainingMarkdown(scanningContext, elementNode) {
+  // Handle code block to be done.
+  // Handle paragraph nodes below.
+  if (lexical.$isParagraphNode(elementNode)) {
+    const paragraphNode = elementNode;
+    const allCriteria = getAllMarkdownCriteria();
+    const count = allCriteria.length;
+
+    for (let i = 0; i < count; i++) {
+      const criteria = allCriteria[i];
+
+      if (criteria.requiresParagraphStart === true) {
+        const firstChild = paragraphNode.getFirstChild();
+
+        if (!lexical.$isTextNode(firstChild)) {
+          throw Error(`Expect paragraph containing only text nodes.`);
+        }
+
+        scanningContext.textNodeWithOffset = {
+          node: firstChild,
+          offset: 0
+        };
+        scanningContext.joinedText = paragraphNode.getTextContent();
+        const patternMatchResults = getPatternMatchResultsForParagraphs(criteria, scanningContext);
+
+        if (patternMatchResults != null) {
+          // Lazy fill-in the particular format criteria and any matching result information.
+          scanningContext.markdownCriteria = criteria;
+          scanningContext.patternMatchResults = patternMatchResults; // Todo: perform text transformation here.
+        }
+      }
+    }
+  }
+}
+
+function convertMarkdownForElementNodes(elementNodes, editor) {
+  // Please see the declaration of ScanningContext for a detailed explanation.
+  const scanningContext = getInitialScanningContext(editor, false, null, null);
+  const count = elementNodes.length;
+
+  for (let i = 0; i < count; i++) {
+    const elementNode = elementNodes[i];
+
+    if (lexical.$isElementNode(elementNode) && elementNode.getTextContent().length && elementNode.getChildren().length) {
+      convertElementNodeContainingMarkdown(scanningContext, elementNode);
+    } // Reset the scanning information that relates to the particular element node.
+
+
+    resetScanningContext(scanningContext);
+  }
+}
+
+/**
+ * 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.
+ *
+ * 
+ */
+function registerMarkdownShortcuts(editor, createHorizontalRuleNode) {
+  // The priorTriggerState is compared against the currentTriggerState to determine
+  // if the user has performed some typing event that warrants an auto format.
+  // For example, typing "#" and then " ", shoud trigger an format.
+  // However, given "#A B", where the user delets "A" should not.
+  let priorTriggerState = null;
+  return editor.registerUpdateListener(({
+    tags
+  }) => {
+    // Examine historic so that we are not running autoformatting within markdown.
+    if (tags.has('historic') === false) {
+      const currentTriggerState = getTriggerState(editor.getEditorState());
+      const scanningContext = currentTriggerState == null ? null : findScanningContext(editor, currentTriggerState, priorTriggerState);
+
+      if (scanningContext != null) {
+        updateAutoFormatting(editor, scanningContext, createHorizontalRuleNode);
+      }
+
+      priorTriggerState = currentTriggerState;
+    } else {
+      priorTriggerState = null;
+    }
+  });
+}
+function $convertFromMarkdownString(markdownString, editor, createHorizontalRuleNode) {
+  convertStringToLexical(markdownString);
+  convertMarkdownForElementNodes(lexical.$getRoot().getChildren(), editor);
+}
+
+exports.$convertFromMarkdownString = $convertFromMarkdownString;
+exports.registerMarkdownShortcuts = registerMarkdownShortcuts;

package/LexicalMarkdown.js

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ */
+'use strict'
+const LexicalMarkdown = process.env.NODE_ENV === 'development' ? require('./LexicalMarkdown.dev.js') : require('./LexicalMarkdown.prod.js')
+module.exports = LexicalMarkdown;

package/LexicalMarkdown.js.flow

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+
+import type {DecoratorNode, LexicalEditor} from 'lexical';
+
+declare export function registerMarkdownShortcuts<T>(
+  editor: LexicalEditor,
+  createHorizontalRuleNode: () => DecoratorNode<T>,
+): () => void;
+declare export function $convertFromMarkdownString(
+  markdownString: string,
+  editor: LexicalEditor,
+): void;

package/LexicalMarkdown.prod.js

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

package/README.md

@@ -0,0 +1,11 @@
+# `@lexical/markdown`
+
+This package contains markdown helpers and functionality for Lexical.
+
+The package focuses on markdown conversion.
+
+The package has 3 main functions:
+
+1. It imports a string and converts into Lexical and then converts markup within the imported nodes. See convertFromPlainTextUtils.js
+2. It exports Lexical to a plain text with markup. See convertToPlainTextUtils.js
+3. It autoformats newly typed text by converting the markdown + some trigger to the appropriate stylized text. See autoFormatUtils.js

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@lexical/markdown",
+  "description": "This package contains Markdown helpers and functionality for Lexical.",
+  "keywords": [
+    "lexical",
+    "editor",
+    "rich-text",
+    "markdown"
+  ],
+  "license": "MIT",
+  "version": "0.1.17",
+  "main": "LexicalMarkdown.js",
+  "peerDependencies": {
+    "lexical": "0.1.17"
+  },
+  "dependencies": {
+    "@lexical/utils": "0.1.17",
+    "@lexical/code": "0.1.17",
+    "@lexical/text": "0.1.17",
+    "@lexical/rich-text": "0.1.17",
+    "@lexical/list": "0.1.17",
+    "@lexical/link": "0.1.17"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/lexical",
+    "directory": "packages/lexical-markdown"
+  }
+}