@lexical/react 0.1.14 → 0.1.17

package/DEPRECATED_useLexicalAutoFormatter.dev.js

@@ -6,600 +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 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.
- *
- * 
- */
-// Caution, this function creates a string and should not be used within a tight loop.
-// Use $getNodeWithOffsetsFromJoinedTextNodesFromElementNode below to convert
-// indexes in the return string back into their corresponding node and offsets.
-
-function $joinTextNodesInElementNode(elementNode, separator, stopAt) {
-  let textContent = '';
-  const children = elementNode.getChildren();
-  const length = children.length;
-
-  for (let i = 0; i < length; ++i) {
-    const child = children[i];
-
-    if (lexical.$isTextNode(child)) {
-      const childTextContent = child.getTextContent();
-
-      if (child.is(stopAt.node)) {
-        if (stopAt.offset > childTextContent.length) {
-          {
-            throw Error(`Node ${child.__key} and selection point do not match.`);
-          }
-        }
-
-        textContent += child.getTextContent().substr(0, stopAt.offset);
-        break;
-      } else {
-        textContent += childTextContent;
-      }
-    } else {
-      textContent += separator;
-    }
-  }
-
-  return textContent;
-} // This function converts the offsetInJoinedText to
-// a node and offset result or null if not found.
-// This function is to be used in conjunction with joinTextNodesInElementNode above.
-// The joinedTextContent should be return value from joinTextNodesInElementNode.
-//
-// The offsetInJoinedText is relative to the entire string which
-// itself is relevant to the parent ElementNode.
-//
-// Example:
-// Given a Paragraph with 2 TextNodes. The first is Hello, the second is World.
-// The joinedTextContent would be "HelloWorld"
-// The offsetInJoinedText might be for the letter "e" = 1 or "r" = 7.
-// The return values would be {TextNode1, 1} or {TextNode2,2}, respectively.
-
-function $findNodeWithOffsetFromJoinedText(elementNode, joinedTextLength, offsetInJoinedText, separatorLength) {
-  const children = elementNode.getChildren();
-  const childrenLength = children.length;
-  let runningLength = 0;
-  let isPriorNodeTextNode = false;
-
-  for (let i = 0; i < childrenLength; ++i) {
-    // We must examine the offsetInJoinedText that is located
-    // at the length of the string.
-    // For example, given "hello", the length is 5, yet
-    // the caller still wants the node + offset at the
-    // right edge of the "o".
-    if (runningLength > joinedTextLength) {
-      break;
-    }
-
-    const child = children[i];
-    const isChildNodeTestNode = lexical.$isTextNode(child);
-    const childContentLength = isChildNodeTestNode ? child.getTextContent().length : separatorLength;
-    const newRunningLength = runningLength + childContentLength;
-    const isJoinedOffsetWithinNode = isPriorNodeTextNode === false && runningLength === offsetInJoinedText || runningLength === 0 && runningLength === offsetInJoinedText || runningLength < offsetInJoinedText && offsetInJoinedText <= newRunningLength;
-
-    if (isJoinedOffsetWithinNode && lexical.$isTextNode(child)) {
-      // Check isTextNode again for flow.
-      return {
-        node: child,
-        offset: offsetInJoinedText - runningLength
-      };
-    }
-
-    runningLength = newRunningLength;
-    isPriorNodeTextNode = isChildNodeTestNode;
-  }
-
-  return null;
-}
-
-/**
- * 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.
- *
- * 
- */
-// 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 TRIGGER_STRING_LENGTH = TRIGGER_STRING.length;
-const SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES = '\u0004'; // Select an unused unicode character to separate text and non-text nodes.
-
-const autoFormatBase = {
-  nodeTransformationKind: null,
-  regEx: /(?:)/,
-  requiresParagraphStart: false
-};
-const paragraphStartBase = { ...autoFormatBase,
-  requiresParagraphStart: true
-};
-const markdownHeader1 = { ...paragraphStartBase,
-  nodeTransformationKind: 'paragraphH1',
-  regEx: /^(?:# )/
-};
-const markdownHeader2 = { ...paragraphStartBase,
-  nodeTransformationKind: 'paragraphH2',
-  regEx: /^(?:## )/
-};
-const markdownHeader3 = { ...paragraphStartBase,
-  nodeTransformationKind: 'paragraphH2',
-  regEx: /^(?:### )/
-};
-const markdownBlockQuote = { ...paragraphStartBase,
-  nodeTransformationKind: 'paragraphBlockQuote',
-  regEx: /^(?:> )/
-};
-const markdownUnorderedListDash = { ...paragraphStartBase,
-  nodeTransformationKind: 'paragraphUnorderedList',
-  regEx: /^(?:- )/
-};
-const markdownUnorderedListAsterisk = { ...paragraphStartBase,
-  nodeTransformationKind: 'paragraphUnorderedList',
-  regEx: /^(?:\* )/
-};
-const markdownCodeBlock = { ...paragraphStartBase,
-  nodeTransformationKind: 'paragraphCodeBlock',
-  regEx: /^(```)([a-z]*)( )/
-};
-const markdownOrderedList = { ...paragraphStartBase,
-  nodeTransformationKind: 'paragraphOrderedList',
-  regEx: /^(\d+)\.\s/
-};
-const markdownHorizontalRule = { ...paragraphStartBase,
-  nodeTransformationKind: 'horizontalRule',
-  regEx: /^(?:\*\*\* )/
-};
-const markdownHorizontalRuleUsingDashes = { ...paragraphStartBase,
-  nodeTransformationKind: 'horizontalRule',
-  regEx: /^(?:--- )/
-};
-const markdownItalic = { ...autoFormatBase,
-  nodeTransformationKind: 'italic',
-  regEx: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*\s)$/
-};
-const markdownBold = { ...autoFormatBase,
-  nodeTransformationKind: 'bold',
-  regEx: /(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*\s)$/
-};
-const markdownBoldWithUnderlines = { ...autoFormatBase,
-  nodeTransformationKind: 'bold',
-  regEx: /(__)(\s*)([^__]*)(\s*)(__\s)$/
-};
-const markdownBoldItalic = { ...autoFormatBase,
-  nodeTransformationKind: '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,
-  nodeTransformationKind: 'underline',
-  regEx: /(\<u\>)(\s*\b)([^\<]*)(\b\s*)(\<\/u\>\s)$/
-};
-const markdownStrikethrough = { ...autoFormatBase,
-  nodeTransformationKind: 'strikethrough',
-  regEx: /(~~)(\s*\b)([^~~]*)(\b\s*)(~~\s)$/
-};
-const allAutoFormatCriteriaForTextNodes = [markdownBoldItalic, markdownItalic, markdownBold, markdownBoldWithUnderlines, fakeMarkdownUnderline, markdownStrikethrough];
-const allAutoFormatCriteria = [markdownHeader1, markdownHeader2, markdownHeader3, markdownBlockQuote, markdownUnorderedListDash, markdownUnorderedListAsterisk, markdownOrderedList, markdownCodeBlock, markdownHorizontalRule, markdownHorizontalRuleUsingDashes, ...allAutoFormatCriteriaForTextNodes];
-function getAllAutoFormatCriteriaForTextNodes() {
-  return allAutoFormatCriteriaForTextNodes;
-}
-function getAllAutoFormatCriteria() {
-  return allAutoFormatCriteria;
-}
-function getInitialScanningContext(textNodeWithOffset, triggerState) {
-  return {
-    autoFormatCriteria: {
-      nodeTransformationKind: 'noTransformation',
-      regEx: /(?:)/,
-      // Empty reg ex will do until the precise criteria is discovered.
-      requiresParagraphStart: null
-    },
-    joinedText: null,
-    matchResultContext: {
-      offsetInJoinedTextForCollapsedSelection: 0,
-      regExCaptureGroups: []
-    },
-    textNodeWithOffset,
-    triggerState
-  };
-}
-
-function getMatchResultContextWithRegEx(textToSearch, matchMustAppearAtStartOfString, matchMustAppearAtEndOfString, regEx) {
-  const matchResultContext = {
-    offsetInJoinedTextForCollapsedSelection: 0,
-    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)) {
-    matchResultContext.offsetInJoinedTextForCollapsedSelection = textToSearch.length;
-    const captureGroupsCount = regExMatches.length;
-    let runningLength = regExMatches.index;
-
-    for (let captureGroupIndex = 0; captureGroupIndex < captureGroupsCount; captureGroupIndex++) {
-      const textContent = regExMatches[captureGroupIndex];
-      matchResultContext.regExCaptureGroups.push({
-        anchorTextNodeWithOffset: null,
-        focusTextNodeWithOffset: null,
-        offsetInParent: runningLength,
-        text: textContent,
-        textLength: textContent.length - (captureGroupIndex + 1 === captureGroupsCount ? TRIGGER_STRING_LENGTH : 0)
-      }); // 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 matchResultContext;
-  }
-
-  return null;
-}
-
-function getMatchResultContextForParagraphs(autoFormatCriteria, scanningContext) {
-  const textNodeWithOffset = scanningContext.textNodeWithOffset; // At start of paragraph.
-
-  if (textNodeWithOffset.node.getPreviousSibling() === null) {
-    const textToSearch = scanningContext.textNodeWithOffset.node.getTextContent();
-    return getMatchResultContextWithRegEx(textToSearch, true, false, autoFormatCriteria.regEx);
-  }
-
-  return null;
-}
-
-function getMatchResultContextForText(autoFormatCriteria, scanningContext) {
-  if (scanningContext.joinedText == null) {
-    const parentNode = scanningContext.textNodeWithOffset.node.getParentOrThrow();
-
-    if (lexical.$isElementNode(parentNode)) {
-      if (scanningContext.joinedText == null) {
-        // Lazy calculate the text to search.
-        scanningContext.joinedText = $joinTextNodesInElementNode(parentNode, SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES, scanningContext.textNodeWithOffset);
-      }
-    } else {
-      {
-        throw Error(`Expected node ${parentNode.__key} to to be a ElementNode.`);
-      }
-    }
-  }
-
-  return getMatchResultContextWithRegEx(scanningContext.joinedText, false, true, autoFormatCriteria.regEx);
-}
-
-function getMatchResultContextForCriteria(autoFormatCriteria, scanningContext) {
-  if (autoFormatCriteria.requiresParagraphStart !== null && autoFormatCriteria.requiresParagraphStart === true) {
-    return getMatchResultContextForParagraphs(autoFormatCriteria, scanningContext);
-  }
-
-  return getMatchResultContextForText(autoFormatCriteria, scanningContext);
-}
-
-function getNewNodeForCriteria(scanningContext, element) {
-  let newNode = null;
-  const children = element.getChildren();
-  const autoFormatCriteria = scanningContext.autoFormatCriteria;
-  const matchResultContext = scanningContext.matchResultContext;
-
-  if (autoFormatCriteria.nodeTransformationKind != null) {
-    switch (autoFormatCriteria.nodeTransformationKind) {
-      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 = matchResultContext.regExCaptureGroups.length > 1 ? matchResultContext.regExCaptureGroups[matchResultContext.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 = matchResultContext.regExCaptureGroups.length >= 3 ? matchResultContext.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 updateTextNode(node, count) {
-  const textNode = node.spliceText(0, count, '', true);
-
-  if (textNode.getTextContent() === '') {
-    textNode.selectPrevious();
-    textNode.remove();
-  }
-}
-
-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.matchResultContext.regExCaptureGroups[0].text;
-  updateTextNode(textNodeWithOffset.node, text.length);
-  const elementNode = getNewNodeForCriteria(scanningContext, element);
-
-  if (elementNode !== null) {
-    element.replace(elementNode);
-  }
-}
-
-function getTextFormatType(nodeTransformationKind) {
-  switch (nodeTransformationKind) {
-    case 'italic':
-    case 'bold':
-    case 'underline':
-    case 'strikethrough':
-      return [nodeTransformationKind];
-
-    case 'bold_italic':
-      {
-        return ['bold', 'italic'];
-      }
-  }
-
-  return null;
-}
-
-function transformTextNodeForText(scanningContext) {
-  const autoFormatCriteria = scanningContext.autoFormatCriteria;
-  const matchResultContext = scanningContext.matchResultContext;
-
-  if (autoFormatCriteria.nodeTransformationKind != null) {
-    if (matchResultContext.regExCaptureGroups.length !== 6) {
-      // For BIUS and other formatts which have a pattern + text + pattern,
-      // the expected reg ex pattern should have 6 groups.
-      // If it does not, then break and fail silently.
-      // e2e tests validate the regEx pattern.
-      return;
-    }
-
-    const formatting = getTextFormatType(autoFormatCriteria.nodeTransformationKind);
-
-    if (formatting != null) {
-      const captureGroupsToDelete = [1, 5];
-      const formatCaptureGroup = 3;
-      matchResultContext.regExCaptureGroups = getCaptureGroupsByResolvingAllDetails(scanningContext);
-
-      if (captureGroupsToDelete.length > 0) {
-        // Remove unwanted text in reg ex pattern.
-        removeTextInCaptureGroups(captureGroupsToDelete, matchResultContext);
-      }
-
-      formatTextInCaptureGroupIndex(formatting, formatCaptureGroup, matchResultContext);
-      makeCollapsedSelectionAtOffsetInJoinedText(matchResultContext.offsetInJoinedTextForCollapsedSelection, matchResultContext.offsetInJoinedTextForCollapsedSelection + 1, scanningContext.textNodeWithOffset.node.getParentOrThrow());
-    }
-  }
-} // Some Capture Group Details were left lazily unresolved as their calculation
-// was not necessary during the scanning phase. Now that the nodeTransformationKind is
-// known, the details may be fully resolved without incurring unwasted performance cost.
-
-
-function getCaptureGroupsByResolvingAllDetails(scanningContext) {
-  const autoFormatCriteria = scanningContext.autoFormatCriteria;
-  const matchResultContext = scanningContext.matchResultContext;
-  const textNodeWithOffset = scanningContext.textNodeWithOffset;
-  const regExCaptureGroups = matchResultContext.regExCaptureGroups;
-  const captureGroupsCount = regExCaptureGroups.length;
-  const parentElementNode = textNodeWithOffset.node.getParentOrThrow();
-
-  if (scanningContext.joinedText == null) {
-    {
-      throw Error(`joinedText was not calculated`);
-    }
-  }
-
-  const joinedTextLength = scanningContext.joinedText.length;
-
-  for (let captureGroupIndex = 1; captureGroupIndex < captureGroupsCount; captureGroupIndex++) {
-    const captureGroupDetail = regExCaptureGroups[captureGroupIndex];
-    captureGroupDetail.anchorTextNodeWithOffset = $findNodeWithOffsetFromJoinedText(parentElementNode, joinedTextLength, captureGroupDetail.offsetInParent, TRIGGER_STRING_LENGTH);
-    captureGroupDetail.focusTextNodeWithOffset = $findNodeWithOffsetFromJoinedText(parentElementNode, joinedTextLength, captureGroupDetail.offsetInParent + captureGroupDetail.textLength, TRIGGER_STRING_LENGTH);
-
-    if (captureGroupDetail.textLength < 0) {
-      {
-        throw Error(`Bad regEx pattern found for ${autoFormatCriteria.nodeTransformationKind}`);
-      }
-    }
-  }
-
-  return regExCaptureGroups;
-}
-
-function removeTextInCaptureGroups(regExCaptureGroupsToDelete, matchResultContext) {
-  const regExCaptureGroups = matchResultContext.regExCaptureGroups;
-  const regExCaptureGroupsCount = regExCaptureGroups.length;
-
-  for (let i = regExCaptureGroupsToDelete.length - 1; i >= 0; i--) {
-    if (i < regExCaptureGroupsCount) {
-      const captureGroupIndex = regExCaptureGroupsToDelete[i];
-      const captureGroupDetail = regExCaptureGroups[captureGroupIndex];
-      const anchorTextNodeWithOffset = captureGroupDetail.anchorTextNodeWithOffset;
-      const focusTextNodeWithOffset = captureGroupDetail.focusTextNodeWithOffset;
-
-      if (anchorTextNodeWithOffset != null && focusTextNodeWithOffset != null && captureGroupDetail.textLength > 0) {
-        const newSelection = lexical.$createRangeSelection();
-        newSelection.anchor.set(anchorTextNodeWithOffset.node.getKey(), anchorTextNodeWithOffset.offset, 'text');
-        newSelection.focus.set(focusTextNodeWithOffset.node.getKey(), focusTextNodeWithOffset.offset, 'text');
-        lexical.$setSelection(newSelection);
-        const currentSelection = lexical.$getSelection();
-
-        if (lexical.$isRangeSelection(currentSelection)) {
-          currentSelection.removeText(); // Shift offsets for capture groups which are within the same node
-
-          if (anchorTextNodeWithOffset.node.getKey() === focusTextNodeWithOffset.node.getKey()) {
-            const delta = focusTextNodeWithOffset.offset - anchorTextNodeWithOffset.offset;
-
-            if (!(delta > 0)) {
-              throw Error(`Expected anchor and focus offsets to have ascending character order.`);
-            }
-
-            shiftCaptureGroupOffsets(-delta, focusTextNodeWithOffset.offset, anchorTextNodeWithOffset.node, captureGroupIndex, matchResultContext);
-          } else {
-            const focusDelta = focusTextNodeWithOffset.offset;
-
-            if (focusDelta > 0) {
-              shiftCaptureGroupOffsets(-focusDelta, focusDelta, focusTextNodeWithOffset.node, captureGroupIndex, matchResultContext);
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-function shiftCaptureGroupOffsets(delta, applyAtOrAfterOffset, node, startingCaptureGroupIndex, matchResultContext) {
-  matchResultContext.offsetInJoinedTextForCollapsedSelection += delta;
-
-  if (!(matchResultContext.offsetInJoinedTextForCollapsedSelection > 0)) {
-    throw Error(`The text content string length does not correlate with insertions/deletions of new text.`);
-  }
-
-  const regExCaptureGroups = matchResultContext.regExCaptureGroups;
-  const regExCaptureGroupsCount = regExCaptureGroups.length;
-
-  for (let captureGroupIndex = startingCaptureGroupIndex + 1; captureGroupIndex < regExCaptureGroupsCount; captureGroupIndex++) {
-    const captureGroupDetail = regExCaptureGroups[captureGroupIndex];
-
-    if (captureGroupDetail.anchorTextNodeWithOffset != null && captureGroupDetail.anchorTextNodeWithOffset.offset >= applyAtOrAfterOffset && captureGroupDetail.anchorTextNodeWithOffset.node.is(node)) {
-      captureGroupDetail.anchorTextNodeWithOffset.offset += delta;
-    }
-
-    if (captureGroupDetail.focusTextNodeWithOffset != null && captureGroupDetail.focusTextNodeWithOffset.offset >= applyAtOrAfterOffset && captureGroupDetail.focusTextNodeWithOffset.node.is(node)) {
-      captureGroupDetail.focusTextNodeWithOffset.offset += delta;
-    }
-  }
-}
-
-function formatTextInCaptureGroupIndex(formatTypes, captureGroupIndex, matchResultContext) {
-  const regExCaptureGroups = matchResultContext.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];
-  const anchorTextNodeWithOffset = captureGroupDetail.anchorTextNodeWithOffset;
-  const focusTextNodeWithOffset = captureGroupDetail.focusTextNodeWithOffset;
-
-  if (anchorTextNodeWithOffset != null && focusTextNodeWithOffset != null && captureGroupDetail.textLength > 0) {
-    const newSelection = lexical.$createRangeSelection();
-    newSelection.anchor.set(anchorTextNodeWithOffset.node.getKey(), anchorTextNodeWithOffset.offset, 'text');
-    newSelection.focus.set(focusTextNodeWithOffset.node.getKey(), focusTextNodeWithOffset.offset, 'text');
-    lexical.$setSelection(newSelection);
-    const currentSelection = lexical.$getSelection();
-
-    if (lexical.$isRangeSelection(currentSelection)) {
-      for (let i = 0; i < formatTypes.length; i++) {
-        currentSelection.formatText(formatTypes[i]);
-      }
-
-      const finalSelection = lexical.$createRangeSelection();
-      finalSelection.anchor.set(focusTextNodeWithOffset.node.getKey(), focusTextNodeWithOffset.offset + 1, 'text');
-      finalSelection.focus.set(focusTextNodeWithOffset.node.getKey(), focusTextNodeWithOffset.offset + 1, 'text');
-      lexical.$setSelection(finalSelection);
-    }
-  }
-}
-
-function makeCollapsedSelectionAtOffsetInJoinedText(offsetInJoinedText, joinedTextLength, parentElementNode) {
-  const textNodeWithOffset = $findNodeWithOffsetFromJoinedText(parentElementNode, joinedTextLength, offsetInJoinedText, TRIGGER_STRING_LENGTH);
-
-  if (textNodeWithOffset != null) {
-    const newSelection = lexical.$createRangeSelection();
-    newSelection.anchor.set(textNodeWithOffset.node.getKey(), textNodeWithOffset.offset, 'text');
-    newSelection.focus.set(textNodeWithOffset.node.getKey(), textNodeWithOffset.offset, 'text');
-    lexical.$setSelection(newSelection);
-  }
-}
+var react = require('react');
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -609,154 +18,9 @@ function makeCollapsedSelectionAtOffsetInJoinedText(offsetInJoinedText, joinedTe
  *
  * 
  */
-
-function getCriteriaWithMatchResultContext(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 nodeTransformationKind calls for toggling the code block.
-
-    if (currentTriggerState != null && currentTriggerState.isCodeBlock === false || autoFormatCriteria.nodeTransformationKind === 'paragraphCodeBlock') {
-      const matchResultContext = getMatchResultContextForCriteria(autoFormatCriteria, scanningContext);
-
-      if (matchResultContext != null) {
-        return {
-          autoFormatCriteria: autoFormatCriteria,
-          matchResultContext
-        };
-      }
-    }
-  }
-
-  return {
-    autoFormatCriteria: null,
-    matchResultContext: 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(editorState, currentTriggerState) {
-  let scanningContext = null;
-  editorState.read(() => {
-    const textNodeWithOffset = getTextNodeForAutoFormatting(lexical.$getSelection());
-
-    if (textNodeWithOffset === null) {
-      return;
-    } // Please see the declaration of ScanningContext for a detailed explanation.
-
-
-    const initialScanningContext = getInitialScanningContext(textNodeWithOffset, currentTriggerState);
-    const criteriaWithMatchResultContext = getCriteriaWithMatchResultContext( // 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 (criteriaWithMatchResultContext.autoFormatCriteria === null || criteriaWithMatchResultContext.matchResultContext === null) {
-      return;
-    }
-
-    scanningContext = initialScanningContext; // Lazy fill-in the particular format criteria and any matching result information.
-
-    scanningContext.autoFormatCriteria = criteriaWithMatchResultContext.autoFormatCriteria;
-    scanningContext.matchResultContext = criteriaWithMatchResultContext.matchResultContext;
-  });
-  return scanningContext;
-}
-
-function findScanningContext(editorState, 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(editorState, 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 editorState = editor.getEditorState();
-        const currentTriggerState = getTriggerState(editorState);
-        const scanningContext = currentTriggerState == null ? null : findScanningContext(editorState, currentTriggerState, priorTriggerState);
-
-        if (scanningContext != null) {
-          updateAutoFormatting(editor, scanningContext);
-        }
-
-        priorTriggerState = currentTriggerState;
-      } else {
-        priorTriggerState = null;
-      }
-    });
+    return markdown.registerMarkdownShortcuts(editor, LexicalHorizontalRuleNode.$createHorizontalRuleNode);
   }, [editor]);
 }
 
@@ -769,7 +33,7 @@ function useAutoFormatter(editor) {
  * 
  */
 function useLexicalAutoFormatter(editor) {
-  useAutoFormatter(editor);
+  useMarkdownShortcuts(editor);
 }
 
 module.exports = useLexicalAutoFormatter;