@lexical/react 0.1.8 → 0.1.11

package/DEPRECATED_useLexical.dev.js

@@ -18,35 +18,11 @@ var useLexicalCanShowPlaceholder = require('@lexical/react/DEPRECATED_useLexical
  *
  * 
  */
-const CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
-
-/**
- * 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.
- *
- * 
- */
-const useLayoutEffectImpl = CAN_USE_DOM ? react.useLayoutEffect : react.useEffect;
-var useLayoutEffect = useLayoutEffectImpl;
-
-/**
- * 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 useLexicalEditor(editor, onError) {
+function useLexicalEditor(editor) {
   const showPlaceholder = useLexicalCanShowPlaceholder(editor);
   const rootElementRef = react.useCallback(rootElement => {
     editor.setRootElement(rootElement);
   }, [editor]);
-  useLayoutEffect(() => {
-    return editor.addListener('error', onError);
-  }, [editor, onError]);
   return [rootElementRef, showPlaceholder];
 }
 
@@ -58,26 +34,15 @@ function useLexicalEditor(editor, onError) {
  *
  * 
  */
-
-function defaultOnErrorHandler(e) {
-  throw e;
-}
-
 function useLexical(editorConfig) {
-  const onError = editorConfig !== undefined && editorConfig.onError || defaultOnErrorHandler;
   const editor = react.useMemo(() => {
     if (editorConfig !== undefined) {
-      // eslint-disable-next-line no-unused-vars
-      const {
-        onError: _onError,
-        ...config
-      } = editorConfig;
-      return lexical.createEditor(config);
+      return lexical.createEditor(editorConfig);
     }
 
     return lexical.createEditor(editorConfig);
   }, [editorConfig]);
-  const [rootElementRef, showPlaceholder] = useLexicalEditor(editor, onError);
+  const [rootElementRef, showPlaceholder] = useLexicalEditor(editor);
   return [editor, rootElementRef, showPlaceholder];
 }
 

package/DEPRECATED_useLexical.prod.js

@@ -4,5 +4,4 @@
  * 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 b=require("lexical"),g=require("react"),h=require("@lexical/react/DEPRECATED_useLexicalCanShowPlaceholder"),k="undefined"!==typeof window&&"undefined"!==typeof window.document&&"undefined"!==typeof window.document.createElement?g.useLayoutEffect:g.useEffect;function l(a,c){const d=h(a),f=g.useCallback(e=>{a.setRootElement(e)},[a]);k(()=>a.addListener("error",c),[a,c]);return[f,d]}function m(a){throw a;}
-module.exports=function(a){const c=void 0!==a&&a.onError||m,d=g.useMemo(()=>{if(void 0!==a){const {onError:p,...n}=a;return b.createEditor(n)}return b.createEditor(a)},[a]),[f,e]=l(d,c);return[d,f,e]};
+var d=require("lexical"),e=require("react"),f=require("@lexical/react/DEPRECATED_useLexicalCanShowPlaceholder");function g(a){const b=f(a);return[e.useCallback(c=>{a.setRootElement(c)},[a]),b]}module.exports=function(a){const b=e.useMemo(()=>d.createEditor(a),[a]),[c,h]=g(b);return[b,c,h]};

package/DEPRECATED_useLexicalAutoFormatter.dev.js

@@ -10,6 +10,7 @@ var list = require('@lexical/list');
 var lexical = require('lexical');
 var CodeNode = require('lexical/CodeNode');
 var react = require('react');
+var LexicalHorizontalRuleNode = require('@lexical/react/LexicalHorizontalRuleNode');
 var HeadingNode = require('lexical/HeadingNode');
 var QuoteNode = require('lexical/QuoteNode');
 
@@ -72,17 +73,26 @@ function $findNodeWithOffsetFromJoinedText(elementNode, joinedTextLength, offset
   const children = elementNode.getChildren();
   const childrenLength = children.length;
   let runningLength = 0;
+  let isPriorNodeTextNode = false;
 
   for (let i = 0; i < childrenLength; ++i) {
-    if (runningLength >= joinedTextLength) {
+    // 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 childContentLength = lexical.$isTextNode(child) ? child.getTextContent().length : separatorLength;
+    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 (runningLength <= offsetInJoinedText && offsetInJoinedText < newRunningLength && lexical.$isTextNode(child)) {
+    if (isJoinedOffsetWithinNode && lexical.$isTextNode(child)) {
+      // Check isTextNode again for flow.
       return {
         node: child,
         offset: offsetInJoinedText - runningLength
@@ -90,6 +100,7 @@ function $findNodeWithOffsetFromJoinedText(elementNode, joinedTextLength, offset
     }
 
     runningLength = newRunningLength;
+    isPriorNodeTextNode = isChildNodeTestNode;
   }
 
   return null;
@@ -114,8 +125,6 @@ const SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES = '\u0004'; // Select an unused
 const autoFormatBase = {
   nodeTransformationKind: null,
   regEx: /(?:)/,
-  regExCaptureGroupsToDelete: null,
-  regExExpectedCaptureGroupCount: 1,
   requiresParagraphStart: false
 };
 const paragraphStartBase = { ...autoFormatBase,
@@ -151,38 +160,77 @@ const markdownCodeBlock = { ...paragraphStartBase,
 };
 const markdownOrderedList = { ...paragraphStartBase,
   nodeTransformationKind: 'paragraphOrderedList',
-  regEx: /^(\d+)\.\s/,
-  regExExpectedCaptureGroupCount: 2
-  /*e.g. '321. ' returns '321. ' & '321'*/
-
+  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: 'textBold',
-  // regEx: /(\*)(?:\s*\b)(?:[^\*]*)(?:\b\s*)(\*\s)$/, // The $ will find the target at the end of the string.
-  regEx: /(\*)(\s*\b)([^\*]*)(\b\s*)(\*\s)$/,
-  // Remove the first and last capture groups. Remeber, the 0th capture group is the entire string.
-  // e.g. "*Hello* " requires removing both "*" as well as bolding "Hello".
-  regExCaptureGroupsToDelete: [1, 5],
-  // The $ will find the target at the end of the string.
-  regExExpectedCaptureGroupCount: 6
+  nodeTransformationKind: 'bold',
+  regEx: /(\*\*)(\s*\b)([^\*\*]*)(\b\s*)(\*\*\s)$/
 };
-const allAutoFormatCriteriaForTextNodes = [markdownBold];
-const allAutoFormatCriteria = [markdownHeader1, markdownHeader2, markdownHeader3, markdownBlockQuote, markdownUnorderedListDash, markdownUnorderedListAsterisk, markdownOrderedList, markdownCodeBlock, ...allAutoFormatCriteriaForTextNodes];
+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, regExExpectedCaptureGroupCount, scanningContext) {
+function getMatchResultContextWithRegEx(textToSearch, matchMustAppearAtStartOfString, matchMustAppearAtEndOfString, regEx) {
   const matchResultContext = {
-    regExCaptureGroups: [],
-    triggerState: null
+    offsetInJoinedTextForCollapsedSelection: 0,
+    regExCaptureGroups: []
   };
   const regExMatches = textToSearch.match(regEx);
 
-  if (regExMatches !== null && regExMatches.length > 0 && regExMatches.length === regExExpectedCaptureGroupCount && (matchMustAppearAtStartOfString === false || regExMatches.index === 0) && (matchMustAppearAtEndOfString === false || regExMatches.index + regExMatches[0].length === textToSearch.length)) {
+  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;
 
@@ -214,7 +262,7 @@ function getMatchResultContextForParagraphs(autoFormatCriteria, scanningContext)
 
   if (textNodeWithOffset.node.getPreviousSibling() === null) {
     const textToSearch = scanningContext.textNodeWithOffset.node.getTextContent();
-    return getMatchResultContextWithRegEx(textToSearch, true, false, autoFormatCriteria.regEx, autoFormatCriteria.regExExpectedCaptureGroupCount);
+    return getMatchResultContextWithRegEx(textToSearch, true, false, autoFormatCriteria.regEx);
   }
 
   return null;
@@ -229,17 +277,14 @@ function getMatchResultContextForText(autoFormatCriteria, scanningContext) {
         // Lazy calculate the text to search.
         scanningContext.joinedText = $joinTextNodesInElementNode(parentNode, SEPARATOR_BETWEEN_TEXT_AND_NON_TEXT_NODES, scanningContext.textNodeWithOffset);
       }
-
-      return getMatchResultContextWithRegEx(scanningContext.joinedText, false, true, autoFormatCriteria.regEx, autoFormatCriteria.regExExpectedCaptureGroupCount);
     } else {
       {
         throw Error(`Expected node ${parentNode.__key} to to be a ElementNode.`);
       }
     }
-  } // This is a placeholder function for following PR's related to character based transformations.
-
+  }
 
-  return null;
+  return getMatchResultContextWithRegEx(scanningContext.joinedText, false, true, autoFormatCriteria.regEx);
 }
 
 function getMatchResultContextForCriteria(autoFormatCriteria, scanningContext) {
@@ -250,8 +295,11 @@ function getMatchResultContextForCriteria(autoFormatCriteria, scanningContext) {
   return getMatchResultContextForText(autoFormatCriteria, scanningContext);
 }
 
-function getNewNodeForCriteria(autoFormatCriteria, matchResultContext, children) {
+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) {
@@ -306,7 +354,7 @@ function getNewNodeForCriteria(autoFormatCriteria, matchResultContext, children)
       case 'paragraphCodeBlock':
         {
           // Toggle code and paragraph nodes.
-          if (matchResultContext.triggerState != null && matchResultContext.triggerState.isCodeBlock) {
+          if (scanningContext.triggerState != null && scanningContext.triggerState.isCodeBlock) {
             newNode = lexical.$createParagraphNode();
           } else {
             newNode = CodeNode.$createCodeNode();
@@ -315,6 +363,14 @@ function getNewNodeForCriteria(autoFormatCriteria, matchResultContext, children)
           newNode.append(...children);
           return newNode;
         }
+
+      case 'horizontalRule':
+        {
+          // return null for newNode. Insert the HR here.
+          const horizontalRuleNode = LexicalHorizontalRuleNode.$createHorizontalRuleNode();
+          element.insertBefore(horizontalRuleNode);
+          break;
+        }
     }
   }
 
@@ -330,41 +386,70 @@ function updateTextNode(node, count) {
   }
 }
 
-function transformTextNodeForAutoFormatCriteria(scanningContext, autoFormatCriteria, matchResultContext) {
-  if (autoFormatCriteria.requiresParagraphStart) {
-    transformTextNodeForParagraphs(scanningContext, autoFormatCriteria, matchResultContext);
+function transformTextNodeForAutoFormatCriteria(scanningContext) {
+  if (scanningContext.autoFormatCriteria.requiresParagraphStart) {
+    transformTextNodeForParagraphs(scanningContext);
   } else {
-    transformTextNodeForText(scanningContext, autoFormatCriteria, matchResultContext);
+    transformTextNodeForText(scanningContext);
   }
 }
 
-function transformTextNodeForParagraphs(scanningContext, autoFormatCriteria, matchResultContext) {
+function transformTextNodeForParagraphs(scanningContext) {
   const textNodeWithOffset = scanningContext.textNodeWithOffset;
   const element = textNodeWithOffset.node.getParentOrThrow();
-  const text = matchResultContext.regExCaptureGroups[0].text;
+  const text = scanningContext.matchResultContext.regExCaptureGroups[0].text;
   updateTextNode(textNodeWithOffset.node, text.length);
-  const elementNode = getNewNodeForCriteria(autoFormatCriteria, matchResultContext, element.getChildren());
+  const elementNode = getNewNodeForCriteria(scanningContext, element);
 
   if (elementNode !== null) {
     element.replace(elementNode);
   }
 }
 
-function transformTextNodeForText(scanningContext, autoFormatCriteria, matchResultContext) {
+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) {
-    switch (autoFormatCriteria.nodeTransformationKind) {
-      case 'textBold':
-        {
-          matchResultContext.regExCaptureGroups = getCaptureGroupsByResolvingAllDetails(scanningContext, autoFormatCriteria, matchResultContext);
+    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;
+    }
 
-          if (autoFormatCriteria.regExCaptureGroupsToDelete != null) {
-            // Remove unwanted text in reg ex patterh.
-            removeTextInCaptureGroups(autoFormatCriteria.regExCaptureGroupsToDelete, matchResultContext);
-            formatTextInCaptureGroupIndex('bold', 3, matchResultContext);
-          }
+    const formatting = getTextFormatType(autoFormatCriteria.nodeTransformationKind);
 
-          break;
-        }
+    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
@@ -372,7 +457,9 @@ function transformTextNodeForText(scanningContext, autoFormatCriteria, matchResu
 // known, the details may be fully resolved without incurring unwasted performance cost.
 
 
-function getCaptureGroupsByResolvingAllDetails(scanningContext, autoFormatCriteria, matchResultContext) {
+function getCaptureGroupsByResolvingAllDetails(scanningContext) {
+  const autoFormatCriteria = scanningContext.autoFormatCriteria;
+  const matchResultContext = scanningContext.matchResultContext;
   const textNodeWithOffset = scanningContext.textNodeWithOffset;
   const regExCaptureGroups = matchResultContext.regExCaptureGroups;
   const captureGroupsCount = regExCaptureGroups.length;
@@ -419,7 +506,7 @@ function removeTextInCaptureGroups(regExCaptureGroupsToDelete, matchResultContex
         lexical.$setSelection(newSelection);
         const currentSelection = lexical.$getSelection();
 
-        if (currentSelection != null) {
+        if (lexical.$isRangeSelection(currentSelection)) {
           currentSelection.removeText(); // Shift offsets for capture groups which are within the same node
 
           if (anchorTextNodeWithOffset.node.getKey() === focusTextNodeWithOffset.node.getKey()) {
@@ -444,6 +531,12 @@ function removeTextInCaptureGroups(regExCaptureGroupsToDelete, matchResultContex
 }
 
 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;
 
@@ -460,7 +553,7 @@ function shiftCaptureGroupOffsets(delta, applyAtOrAfterOffset, node, startingCap
   }
 }
 
-function formatTextInCaptureGroupIndex(formatType, captureGroupIndex, matchResultContext) {
+function formatTextInCaptureGroupIndex(formatTypes, captureGroupIndex, matchResultContext) {
   const regExCaptureGroups = matchResultContext.regExCaptureGroups;
   const regExCaptureGroupsCount = regExCaptureGroups.length;
 
@@ -479,12 +572,30 @@ function formatTextInCaptureGroupIndex(formatType, captureGroupIndex, matchResul
     lexical.$setSelection(newSelection);
     const currentSelection = lexical.$getSelection();
 
-    if (currentSelection != null) {
-      currentSelection.formatText(formatType);
+    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);
+  }
+}
+
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -494,17 +605,17 @@ function formatTextInCaptureGroupIndex(formatType, captureGroupIndex, matchResul
  * 
  */
 
-function getCriteriaWithMatchResultContext(autoFormatCriteriaArray, currentTriggerState, scanningContext) {
+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.isCodeBlock === false || autoFormatCriteria.nodeTransformationKind === 'paragraphCodeBlock') {
+    if (currentTriggerState != null && currentTriggerState.isCodeBlock === false || autoFormatCriteria.nodeTransformationKind === 'paragraphCodeBlock') {
       const matchResultContext = getMatchResultContextForCriteria(autoFormatCriteria, scanningContext);
 
       if (matchResultContext != null) {
-        matchResultContext.triggerState = currentTriggerState;
         return {
           autoFormatCriteria: autoFormatCriteria,
           matchResultContext
@@ -520,7 +631,7 @@ function getCriteriaWithMatchResultContext(autoFormatCriteriaArray, currentTrigg
 }
 
 function getTextNodeForAutoFormatting(selection) {
-  if (selection == null) {
+  if (!lexical.$isRangeSelection(selection)) {
     return null;
   }
 
@@ -536,8 +647,17 @@ function getTextNodeForAutoFormatting(selection) {
   };
 }
 
-function updateAutoFormatting(editor, currentTriggerState) {
+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) {
@@ -545,24 +665,25 @@ function updateAutoFormatting(editor, currentTriggerState) {
     } // Please see the declaration of ScanningContext for a detailed explanation.
 
 
-    const scanningContext = {
-      joinedText: null,
-      textNodeWithOffset
-    };
+    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(), currentTriggerState, scanningContext);
+    currentTriggerState.isParentAListItemNode === false ? getAllAutoFormatCriteria() : getAllAutoFormatCriteriaForTextNodes(), initialScanningContext);
 
     if (criteriaWithMatchResultContext.autoFormatCriteria === null || criteriaWithMatchResultContext.matchResultContext === null) {
       return;
     }
 
-    transformTextNodeForAutoFormatCriteria(scanningContext, criteriaWithMatchResultContext.autoFormatCriteria, criteriaWithMatchResultContext.matchResultContext);
+    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 shouldAttemptToAutoFormat(currentTriggerState, priorTriggerState) {
+function findScanningContext(editorState, currentTriggerState, priorTriggerState) {
   if (currentTriggerState == null || priorTriggerState == null) {
-    return false;
+    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 (" ").
@@ -571,7 +692,12 @@ function shouldAttemptToAutoFormat(currentTriggerState, priorTriggerState) {
   const triggerStringLength = TRIGGER_STRING.length;
   const currentTextContentLength = currentTriggerState.textContent.length;
   const triggerOffset = currentTriggerState.anchorOffset - triggerStringLength;
-  return 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;
+
+  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) {
@@ -579,7 +705,7 @@ function getTriggerState(editorState) {
   editorState.read(() => {
     const selection = lexical.$getSelection();
 
-    if (selection == null || !selection.isCollapsed()) {
+    if (!lexical.$isRangeSelection(selection) || !selection.isCollapsed()) {
       return;
     }
 
@@ -608,15 +734,17 @@ function useAutoFormatter(editor) {
     // For example, typing "#" and then " ", shoud trigger an format.
     // However, given "#A B", where the user delets "A" should not.
     let priorTriggerState = null;
-    editor.addListener('update', ({
+    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 editorState = editor.getEditorState();
+        const currentTriggerState = getTriggerState(editorState);
+        const scanningContext = currentTriggerState == null ? null : findScanningContext(editorState, currentTriggerState, priorTriggerState);
 
-        if (shouldAttemptToAutoFormat(currentTriggerState, priorTriggerState) && currentTriggerState != null) {
-          updateAutoFormatting(editor, currentTriggerState);
+        if (scanningContext != null) {
+          updateAutoFormatting(editor, scanningContext);
         }
 
         priorTriggerState = currentTriggerState;