@lexical/react 0.1.15 → 0.1.18

package/DEPRECATED_useLexicalAutoFormatter.dev.js

@@ -6,589 +6,9 @@
  */
 'use strict';
 
-var list = require('@lexical/list');
-var lexical = require('lexical');
-var CodeNode = require('lexical/CodeNode');
-var react = require('react');
+var markdown = require('@lexical/markdown');
 var LexicalHorizontalRuleNode = require('@lexical/react/LexicalHorizontalRuleNode');
-var text = require('@lexical/text');
-var HeadingNode = require('lexical/HeadingNode');
-var QuoteNode = require('lexical/QuoteNode');
-
-/**
- * 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 allAutoFormatCriteria or 
-   your text criteria (e.g. *MyItalic*) to allAutoFormatCriteriaForTextNodes.
-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.
-
-const TRIGGER_STRING = '\u0020'; // The space key triggers markdown.
-
-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; // Todo: speed up performance by having non-capture group variations of the regex.
-
-const autoFormatBase = {
-  autoFormatKind: null,
-  regEx: /(?:)/,
-  requiresParagraphStart: false
-};
-const paragraphStartBase = { ...autoFormatBase,
-  requiresParagraphStart: true
-};
-const markdownHeader1 = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphH1',
-  regEx: /^(?:# )/
-};
-const markdownHeader2 = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphH2',
-  regEx: /^(?:## )/
-};
-const markdownHeader3 = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphH2',
-  regEx: /^(?:### )/
-};
-const markdownBlockQuote = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphBlockQuote',
-  regEx: /^(?:> )/
-};
-const markdownUnorderedListDash = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphUnorderedList',
-  regEx: /^(?:- )/
-};
-const markdownUnorderedListAsterisk = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphUnorderedList',
-  regEx: /^(?:\* )/
-};
-const markdownCodeBlock = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphCodeBlock',
-  regEx: /^(```)([a-z]*)( )/
-};
-const markdownOrderedList = { ...paragraphStartBase,
-  autoFormatKind: 'paragraphOrderedList',
-  regEx: /^(\d+)\.\s/
-};
-const markdownHorizontalRule = { ...paragraphStartBase,
-  autoFormatKind: 'horizontalRule',
-  regEx: /^(?:\*\*\* )/
-};
-const markdownHorizontalRuleUsingDashes = { ...paragraphStartBase,
-  autoFormatKind: 'horizontalRule',
-  regEx: /^(?:--- )/
-};
-const markdownItalic = { ...autoFormatBase,
-  autoFormatKind: 'italic',
-  regEx: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*)(\s)$/
-};
-const markdownBold = { ...autoFormatBase,
-  autoFormatKind: 'bold',
-  regEx: /(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*)(\s)$/
-};
-const markdownBoldWithUnderlines = { ...autoFormatBase,
-  autoFormatKind: 'bold',
-  regEx: /(__)(\s*)([^__]*)(\s*)(__)(\s)$/
-};
-const markdownBoldItalic = { ...autoFormatBase,
-  autoFormatKind: 'bold_italic',
-  regEx: /(\*\*\*)(\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\>)(\s)$/
-};
-const markdownStrikethrough = { ...autoFormatBase,
-  autoFormatKind: 'strikethrough',
-  regEx: /(~~)(\s*\b)([^~~]*)(\b\s*)(~~)(\s)$/
-};
-const markdownLink = { ...autoFormatBase,
-  autoFormatKind: 'link',
-  regEx: /(\[)(.+)(\]\()([^ ]+)(?: \"(?:.+)\")?(\))(\s)$/
-};
-const allAutoFormatCriteriaForTextNodes = [markdownBoldItalic, markdownItalic, markdownBold, markdownBoldWithUnderlines, fakeMarkdownUnderline, markdownStrikethrough, markdownLink];
-const allAutoFormatCriteria = [markdownHeader1, markdownHeader2, markdownHeader3, markdownBlockQuote, markdownUnorderedListDash, markdownUnorderedListAsterisk, markdownOrderedList, markdownCodeBlock, markdownHorizontalRule, markdownHorizontalRuleUsingDashes, ...allAutoFormatCriteriaForTextNodes];
-function getAllAutoFormatCriteriaForTextNodes() {
-  return allAutoFormatCriteriaForTextNodes;
-}
-function getAllAutoFormatCriteria() {
-  return allAutoFormatCriteria;
-}
-function getInitialScanningContext(editor, textNodeWithOffset, triggerState) {
-  return {
-    autoFormatCriteria: {
-      autoFormatKind: 'noTransformation',
-      regEx: /(?:)/,
-      // Empty reg ex will do until the precise criteria is discovered.
-      requiresParagraphStart: null
-    },
-    editor,
-    joinedText: null,
-    patternMatchResults: {
-      regExCaptureGroups: []
-    },
-    textNodeWithOffset,
-    triggerState
-  };
-}
-
-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 getPatternMatchResultsForParagraphs(autoFormatCriteria, scanningContext) {
-  const textNodeWithOffset = scanningContext.textNodeWithOffset; // At start of paragraph.
-
-  if (textNodeWithOffset.node.getPreviousSibling() === null) {
-    const textToSearch = scanningContext.textNodeWithOffset.node.getTextContent();
-    return getPatternMatchResultsWithRegEx(textToSearch, true, false, autoFormatCriteria.regEx);
-  }
-
-  return null;
-}
-
-function getPatternMatchResultsForText(autoFormatCriteria, 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, scanningContext.textNodeWithOffset);
-      }
-    } else {
-      {
-        throw Error(`Expected node ${parentNode.__key} to to be a ElementNode.`);
-      }
-    }
-  }
-
-  return getPatternMatchResultsWithRegEx(scanningContext.joinedText, false, true, autoFormatCriteria.regEx);
-}
-
-function getPatternMatchResultsForCriteria(autoFormatCriteria, scanningContext) {
-  if (autoFormatCriteria.requiresParagraphStart !== null && autoFormatCriteria.requiresParagraphStart === true) {
-    return getPatternMatchResultsForParagraphs(autoFormatCriteria, scanningContext);
-  }
-
-  return getPatternMatchResultsForText(autoFormatCriteria, scanningContext);
-}
-
-function getNewNodeForCriteria(scanningContext, element) {
-  let newNode = null;
-  const children = element.getChildren();
-  const autoFormatCriteria = scanningContext.autoFormatCriteria;
-  const patternMatchResults = scanningContext.patternMatchResults;
-
-  if (autoFormatCriteria.autoFormatKind != null) {
-    switch (autoFormatCriteria.autoFormatKind) {
-      case 'paragraphH1':
-        {
-          newNode = HeadingNode.$createHeadingNode('h1');
-          newNode.append(...children);
-          return newNode;
-        }
-
-      case 'paragraphH2':
-        {
-          newNode = HeadingNode.$createHeadingNode('h2');
-          newNode.append(...children);
-          return newNode;
-        }
-
-      case 'paragraphH3':
-        {
-          newNode = HeadingNode.$createHeadingNode('h3');
-          newNode.append(...children);
-          return newNode;
-        }
-
-      case 'paragraphBlockQuote':
-        {
-          newNode = QuoteNode.$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 = CodeNode.$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 = LexicalHorizontalRuleNode.$createHorizontalRuleNode();
-          element.insertBefore(horizontalRuleNode);
-          break;
-        }
-    }
-  }
-
-  return newNode;
-}
-
-function transformTextNodeForAutoFormatCriteria(scanningContext) {
-  if (scanningContext.autoFormatCriteria.requiresParagraphStart) {
-    transformTextNodeForParagraphs(scanningContext);
-  } else {
-    transformTextNodeForText(scanningContext);
-  }
-}
-
-function transformTextNodeForParagraphs(scanningContext) {
-  const textNodeWithOffset = scanningContext.textNodeWithOffset;
-  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);
-
-  if (elementNode !== null) {
-    element.replace(elementNode);
-  }
-}
-
-function transformTextNodeForText(scanningContext) {
-  const autoFormatCriteria = scanningContext.autoFormatCriteria;
-
-  if (autoFormatCriteria.autoFormatKind != null) {
-    const formatting = getTextFormatType(autoFormatCriteria.autoFormatKind);
-
-    if (formatting != null) {
-      transformTextNodeWithFormatting(formatting, scanningContext);
-      return;
-    }
-
-    if (autoFormatCriteria.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.execCommand('toggleLink', url); // Place caret at end of final capture group.
-
-  selectAfterFinalCaptureGroup(scanningContext);
-} // Below are lower level helper functions.
-
-
-function getParent(scanningContext) {
-  return scanningContext.textNodeWithOffset.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);
-  }
-}
+var react = require('react');
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -598,153 +18,9 @@ function selectAfterFinalCaptureGroup(scanningContext) {
  *
  * 
  */
-
-function getCriteriaWithPatternMatchResults(autoFormatCriteriaArray, scanningContext) {
-  const currentTriggerState = scanningContext.triggerState;
-  const count = autoFormatCriteriaArray.length;
-
-  for (let i = 0; i < count; i++) {
-    const autoFormatCriteria = autoFormatCriteriaArray[i]; // Skip code block nodes, unless the autoFormatKind calls for toggling the code block.
-
-    if (currentTriggerState != null && currentTriggerState.isCodeBlock === false || autoFormatCriteria.autoFormatKind === 'paragraphCodeBlock') {
-      const patternMatchResults = getPatternMatchResultsForCriteria(autoFormatCriteria, scanningContext);
-
-      if (patternMatchResults != null) {
-        return {
-          autoFormatCriteria: autoFormatCriteria,
-          patternMatchResults
-        };
-      }
-    }
-  }
-
-  return {
-    autoFormatCriteria: null,
-    patternMatchResults: null
-  };
-}
-
-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) {
-  editor.update(() => {
-    transformTextNodeForAutoFormatCriteria(scanningContext);
-  }, {
-    tag: 'history-push'
-  });
-}
-
-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, 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 ? getAllAutoFormatCriteria() : getAllAutoFormatCriteriaForTextNodes(), initialScanningContext);
-
-    if (criteriaWithPatternMatchResults.autoFormatCriteria === null || criteriaWithPatternMatchResults.patternMatchResults === null) {
-      return;
-    }
-
-    scanningContext = initialScanningContext; // Lazy fill-in the particular format criteria and any matching result information.
-
-    scanningContext.autoFormatCriteria = criteriaWithPatternMatchResults.autoFormatCriteria;
-    scanningContext.patternMatchResults = criteriaWithPatternMatchResults.patternMatchResults;
-  });
-  return scanningContext;
-}
-
-function findScanningContext(editor, currentTriggerState, priorTriggerState) {
-  if (currentTriggerState == null || priorTriggerState == null) {
-    return null;
-  } // 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 = TRIGGER_STRING.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) === TRIGGER_STRING && currentTriggerState.textContent !== priorTriggerState.textContent) === false) {
-    return null;
-  }
-
-  return findScanningContextWithValidMatch(editor, currentTriggerState);
-}
-
-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 = parentNode !== null && list.$isListItemNode(parentNode);
-    const hasParentNode = parentNode !== null;
-    criteria = {
-      anchorOffset: selection.anchor.offset,
-      hasParentNode,
-      isCodeBlock: CodeNode.$isCodeNode(node),
-      isParentAListItemNode,
-      isSelectionCollapsed: selection.isCollapsed(),
-      isSimpleText: lexical.$isTextNode(node) && node.isSimpleText(),
-      nodeKey: node.getKey(),
-      textContent: node.getTextContent()
-    };
-  });
-  return criteria;
-}
-
-function useAutoFormatter(editor) {
+function useMarkdownShortcuts(editor) {
   react.useEffect(() => {
-    // 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.addListener('update', ({
-      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);
-        }
-
-        priorTriggerState = currentTriggerState;
-      } else {
-        priorTriggerState = null;
-      }
-    });
+    return markdown.registerMarkdownShortcuts(editor, LexicalHorizontalRuleNode.$createHorizontalRuleNode);
   }, [editor]);
 }
 
@@ -757,7 +33,7 @@ function useAutoFormatter(editor) {
  * 
  */
 function useLexicalAutoFormatter(editor) {
-  useAutoFormatter(editor);
+  useMarkdownShortcuts(editor);
 }
 
 module.exports = useLexicalAutoFormatter;