lexical 0.1.8 → 0.1.9

package/Lexical.dev.js

@@ -14,7 +14,7 @@
  *
  * 
  */
-const VERSION = '0.1.8'; // DOM
+const VERSION = '0.1.9'; // DOM
 
 const DOM_ELEMENT_TYPE = 1;
 const DOM_TEXT_TYPE = 3; // Reconciling
@@ -159,7 +159,6 @@ function $flushMutations$1(editor, mutations, observer) {
 
   try {
     updateEditor(editor, () => {
-      $pushLogEntry('onMutation');
       const badDOMTargets = new Map();
       const rootElement = editor.getRootElement(); // We use the current edtior state, as that reflects what is
       // actually "on screen".
@@ -218,7 +217,7 @@ function $flushMutations$1(editor, mutations, observer) {
 
             if (removedDOMsLength !== unremovedBRs) {
               if (targetDOM === rootElement) {
-                targetNode = $getRoot(currentEditorState);
+                targetNode = internalGetRoot(currentEditorState);
               }
 
               badDOMTargets.set(targetDOM, targetNode);
@@ -299,7 +298,7 @@ function $flushMutations$1(editor, mutations, observer) {
           $setSelection(selection);
         }
       }
-    }, true);
+    });
   } finally {
     isProcessingMutations = false;
   }
@@ -400,9 +399,14 @@ function toggleTextFormatType(format, type, alignWithFormat) {
   return format;
 }
 function $isLeafNode(node) {
-  return $isTextNode(node) || $isLineBreakNode(node) || $isDecoratorNode(node) || $isHorizontalRuleNode(node);
+  return $isTextNode(node) || $isLineBreakNode(node) || $isDecoratorNode(node);
 }
-function $generateKey(node) {
+function $setNodeKey(node, existingKey) {
+  if (existingKey != null) {
+    node.__key = existingKey;
+    return;
+  }
+
   errorOnReadOnly();
   errorOnInfiniteTransforms();
   const editor = getActiveEditor();
@@ -421,10 +425,10 @@ function $generateKey(node) {
   editor._cloneNotNeeded.add(key);
 
   editor._dirtyType = HAS_DIRTY_NODES;
-  return key;
+  node.__key = key;
 }
 
-function $internallyMarkParentElementsAsDirty(parentKey, nodeMap, dirtyElements) {
+function internalMarkParentElementsAsDirty(parentKey, nodeMap, dirtyElements) {
   let nextParentKey = parentKey;
 
   while (nextParentKey !== null) {
@@ -445,7 +449,7 @@ function $internallyMarkParentElementsAsDirty(parentKey, nodeMap, dirtyElements)
 // the cloning heuristic. Instead use node.getWritable().
 
 
-function $internallyMarkNodeAsDirty(node) {
+function internalMarkNodeAsDirty(node) {
   errorOnInfiniteTransforms();
   const latest = node.getLatest();
   const parent = latest.__parent;
@@ -455,7 +459,7 @@ function $internallyMarkNodeAsDirty(node) {
   const dirtyElements = editor._dirtyElements;
 
   if (parent !== null) {
-    $internallyMarkParentElementsAsDirty(parent, nodeMap, dirtyElements);
+    internalMarkParentElementsAsDirty(parent, nodeMap, dirtyElements);
   }
 
   const key = latest.__key;
@@ -468,16 +472,16 @@ function $internallyMarkNodeAsDirty(node) {
     editor._dirtyLeaves.add(key);
   }
 }
-function $internallyMarkSiblingsAsDirty(node) {
+function internalMarkSiblingsAsDirty(node) {
   const previousNode = node.getPreviousSibling();
   const nextNode = node.getNextSibling();
 
   if (previousNode !== null) {
-    $internallyMarkNodeAsDirty(previousNode);
+    internalMarkNodeAsDirty(previousNode);
   }
 
   if (nextNode !== null) {
-    $internallyMarkNodeAsDirty(nextNode);
+    internalMarkNodeAsDirty(nextNode);
   }
 }
 function $setCompositionKey(compositionKey) {
@@ -549,11 +553,6 @@ function cloneDecorators(editor) {
   editor._pendingDecorators = pendingDecorators;
   return pendingDecorators;
 }
-function $pushLogEntry(entry) {
-  const editor = getActiveEditor();
-
-  editor._log.push(entry);
-}
 function getEditorStateTextContent(editorState) {
   return editorState.read(view => $getRoot().getTextContent());
 }
@@ -579,12 +578,15 @@ function markAllNodesAsDirty(editor, type) {
       const node = nodeMapEntries[i][1];
       node.markDirty();
     }
-  }, true, editor._pendingEditorState === null ? {
-    tag: 'without-history'
+  }, editor._pendingEditorState === null ? {
+    tag: 'history-merge'
   } : undefined);
 }
-function $getRoot(editorState) {
-  return (editorState || getActiveEditorState())._nodeMap.get('root' // $FlowFixMe: root is always in our Map
+function $getRoot() {
+  return internalGetRoot(getActiveEditorState());
+}
+function internalGetRoot(editorState) {
+  return editorState._nodeMap.get('root' // $FlowFixMe: root is always in our Map
   );
 }
 function $setSelection(selection) {
@@ -896,6 +898,25 @@ function getCachedClassNameArray(classNamesTheme, classNameThemeType) {
 
   return classNames;
 }
+function setMutatedNode(mutatedNodes, registeredNodes, node, mutation) {
+  const registeredNode = registeredNodes.get(node.__type);
+
+  if (registeredNode === undefined) {
+    {
+      throw Error(`Type ${node.__type} not in registeredNodes`);
+    }
+  }
+
+  const klass = registeredNode.klass;
+  let mutatedNodesByType = mutatedNodes.get(klass);
+
+  if (mutatedNodesByType === undefined) {
+    mutatedNodesByType = new Map();
+    mutatedNodes.set(klass, mutatedNodesByType);
+  }
+
+  mutatedNodesByType.set(node.__key, mutation);
+}
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -1065,17 +1086,41 @@ function $normalizeTextNode(textNode) {
  *
  * 
  */
+function resolveElement(element, isBackward, focusOffset) {
+  const parent = element.getParent();
+  let offset = focusOffset;
+  let block = element;
+
+  if (parent !== null) {
+    if (isBackward && focusOffset === 0) {
+      offset = block.getIndexWithinParent();
+      block = parent;
+    } else if (!isBackward && focusOffset === block.getChildrenSize()) {
+      offset = block.getIndexWithinParent() + 1;
+      block = parent;
+    }
+  }
+
+  return block.getChildAtIndex(isBackward ? offset - 1 : offset);
+}
+
 function getPossibleDecoratorNode(focus, isBackward) {
   const focusOffset = focus.offset;
 
   if (focus.type === 'element') {
     const block = focus.getNode();
-    return block.getChildAtIndex(isBackward ? focusOffset - 1 : focusOffset);
+    return resolveElement(block, isBackward, focusOffset);
   } else {
     const focusNode = focus.getNode();
 
     if (isBackward && focusOffset === 0 || !isBackward && focusOffset === focusNode.getTextContentSize()) {
-      return isBackward ? focusNode.getPreviousSibling() : focusNode.getNextSibling();
+      const possibleNode = isBackward ? focusNode.getPreviousSibling() : focusNode.getNextSibling();
+
+      if (possibleNode === null) {
+        return resolveElement(focusNode.getParentOrThrow(), isBackward, focusNode.getIndexWithinParent() + (isBackward ? 0 : 1));
+      }
+
+      return possibleNode;
     }
   }
 
@@ -1200,15 +1245,20 @@ function $transferStartingElementPointToTextPoint(start, end, format) {
   const element = start.getNode();
   const placementNode = element.getChildAtIndex(start.offset);
   const textNode = $createTextNode();
+  const target = $isRootNode(element) ? $createParagraphNode().append(textNode) : textNode;
   textNode.setFormat(format);
 
   if (placementNode === null) {
-    element.append(textNode);
+    element.append(target);
   } else {
-    placementNode.insertBefore(textNode);
+    placementNode.insertBefore(target);
   } // Transfer the element point to a text point.
 
 
+  if (start.is(end)) {
+    end.set(textNode.getKey(), 0, 'text');
+  }
+
   start.set(textNode.getKey(), 0, 'text');
 }
 
@@ -1322,7 +1372,7 @@ class RangeSelection {
           }
 
           textContent += text;
-        } else if (($isDecoratorNode(node) || $isLineBreakNode(node) || $isHorizontalRuleNode(node)) && (node !== lastNode || !this.isCollapsed())) {
+        } else if (($isDecoratorNode(node) || $isLineBreakNode(node)) && (node !== lastNode || !this.isCollapsed())) {
           textContent += node.getTextContent();
         }
       }
@@ -1333,7 +1383,9 @@ class RangeSelection {
 
   applyDOMRange(range) {
     const editor = getActiveEditor();
-    const resolvedSelectionPoints = internalResolveSelectionPoints(range.startContainer, range.startOffset, range.endContainer, range.endOffset, editor);
+    const currentEditorState = editor.getEditorState();
+    const lastSelection = currentEditorState._selection;
+    const resolvedSelectionPoints = internalResolveSelectionPoints(range.startContainer, range.startOffset, range.endContainer, range.endOffset, editor, lastSelection);
 
     if (resolvedSelectionPoints === null) {
       return;
@@ -1591,7 +1643,7 @@ class RangeSelection {
         const selectedNode = selectedNodes[i];
         const key = selectedNode.getKey();
 
-        if (!markedNodeKeysForKeep.has(key) && (!$isElementNode(selectedNode) || selectedNode.canSelectionRemove())) {
+        if (!markedNodeKeysForKeep.has(key)) {
           selectedNode.remove();
         }
       }
@@ -1752,7 +1804,7 @@ class RangeSelection {
     // append them after the last node we're inserting.
 
     const nextSiblings = anchorNode.getNextSiblings();
-    const topLevelElement = anchorNode.getTopLevelElementOrThrow();
+    const topLevelElement = $isRootNode(anchorNode) ? null : anchorNode.getTopLevelElementOrThrow();
 
     if ($isTextNode(anchorNode)) {
       const textContent = anchorNode.getTextContent();
@@ -1869,9 +1921,15 @@ class RangeSelection {
         }
 
         if ($isTextNode(target)) {
+          if (topLevelElement === null) {
+            {
+              throw Error(`insertNode: topLevelElement is root node`);
+            }
+          }
+
           target = topLevelElement;
         }
-      } else if (didReplaceOrMerge && $isRootNode(target.getParent())) {
+      } else if (didReplaceOrMerge && !$isDecoratorNode(node) && $isRootNode(target.getParent())) {
         {
           throw Error(`insertNodes: cannot insert a non-element into a root node`);
         }
@@ -1880,7 +1938,9 @@ class RangeSelection {
       didReplaceOrMerge = false;
 
       if ($isElementNode(target)) {
-        if (!$isElementNode(node)) {
+        if ($isDecoratorNode(node) && node.isTopLevel()) {
+          target = target.insertAfter(node);
+        } else if (!$isElementNode(node)) {
           const firstChild = target.getFirstChild();
 
           if (firstChild !== null) {
@@ -1895,9 +1955,21 @@ class RangeSelection {
             continue;
           }
 
-          target = target.insertAfter(node);
+          if ($isRootNode(target)) {
+            const placementNode = target.getChildAtIndex(anchorOffset);
+
+            if (placementNode !== null) {
+              placementNode.insertBefore(node);
+            } else {
+              target.append(node);
+            }
+
+            target = node;
+          } else {
+            target = target.insertAfter(node);
+          }
         }
-      } else if (!$isElementNode(node)) {
+      } else if (!$isElementNode(node) || $isDecoratorNode(target) && target.isTopLevel()) {
         target = target.insertAfter(node);
       } else {
         target = node.getParentOrThrow(); // Re-try again with the target being the parent
@@ -2008,6 +2080,21 @@ class RangeSelection {
       }
     } else {
       currentElement = anchor.getNode();
+
+      if ($isRootNode(currentElement)) {
+        const paragraph = $createParagraphNode();
+        const child = currentElement.getChildAtIndex(anchorOffset);
+        paragraph.select();
+
+        if (child !== null) {
+          child.insertBefore(paragraph);
+        } else {
+          currentElement.append(paragraph);
+        }
+
+        return;
+      }
+
       nodesToMove = currentElement.getChildren().slice(anchorOffset).reverse();
     }
 
@@ -2045,6 +2132,15 @@ class RangeSelection {
 
   insertLineBreak(selectStart) {
     const lineBreakNode = $createLineBreakNode();
+    const anchor = this.anchor;
+
+    if (anchor.type === 'element') {
+      const element = anchor.getNode();
+
+      if ($isRootNode(element)) {
+        this.insertParagraph();
+      }
+    }
 
     if (selectStart) {
       this.insertNodes([lineBreakNode], true);
@@ -2114,17 +2210,26 @@ class RangeSelection {
     const anchor = this.anchor;
     const collapse = alter === 'move'; // Handle the selection movement around decorators.
 
-    const possibleDecoratorNode = getPossibleDecoratorNode(focus, isBackward);
+    const possibleNode = getPossibleDecoratorNode(focus, isBackward);
 
-    if ($isDecoratorNode(possibleDecoratorNode)) {
-      const sibling = isBackward ? possibleDecoratorNode.getPreviousSibling() : possibleDecoratorNode.getNextSibling();
+    if ($isDecoratorNode(possibleNode) && !possibleNode.isIsolated()) {
+      const sibling = isBackward ? possibleNode.getPreviousSibling() : possibleNode.getNextSibling();
 
       if (!$isTextNode(sibling)) {
-        const elementKey = possibleDecoratorNode.getParentOrThrow().getKey();
-        let offset = possibleDecoratorNode.getIndexWithinParent();
+        const parent = possibleNode.getParentOrThrow();
+        let offset;
+        let elementKey;
+
+        if ($isElementNode(sibling)) {
+          elementKey = sibling.getKey();
+          offset = isBackward ? sibling.getChildrenSize() : 0;
+        } else {
+          offset = possibleNode.getIndexWithinParent();
+          elementKey = parent.getKey();
 
-        if (!isBackward) {
-          offset++;
+          if (!isBackward) {
+            offset++;
+          }
         }
 
         focus.set(elementKey, offset, 'element');
@@ -2165,9 +2270,7 @@ class RangeSelection {
       const focus = this.focus;
       let anchorNode = anchor.getNode();
 
-      if ($isElementNode(anchorNode) && !anchorNode.canSelectionRemove()) {
-        return;
-      } else if (!isBackward && ( // Delete forward handle case
+      if (!isBackward && ( // Delete forward handle case
       anchor.type === 'element' && // $FlowFixMe: always an element node
       anchor.offset === anchorNode.getChildrenSize() || anchor.type === 'text' && anchor.offset === anchorNode.getTextContentSize())) {
         const nextSibling = anchorNode.getNextSibling() || anchorNode.getParentOrThrow().getNextSibling();
@@ -2334,7 +2437,12 @@ function $removeSegment(node, isBackward) {
   }
 }
 
-function internalResolveSelectionPoint(dom, offset) {
+function shouldResolveAncestor(resolvedElement, resolvedOffset, lastPoint) {
+  const parent = resolvedElement.getParent();
+  return lastPoint === null || parent === null || !parent.canBeEmpty() || parent !== lastPoint.getNode();
+}
+
+function internalResolveSelectionPoint(dom, offset, lastPoint) {
   let resolvedOffset = offset;
   let resolvedNode; // If we have selection on an element, we will
   // need to figure out (using the offset) what text
@@ -2360,9 +2468,6 @@ function internalResolveSelectionPoint(dom, offset) {
 
     if ($isTextNode(resolvedNode)) {
       resolvedOffset = getTextNodeOffset(resolvedNode, moveSelectionToEnd);
-    } else if ($isHorizontalRuleNode(resolvedNode)) {
-      resolvedOffset = 0;
-      return $createPoint(resolvedNode.__key, resolvedOffset, 'element');
     } else {
       let resolvedElement = getNodeFromDOM(dom); // Ensure resolvedElement is actually a element.
 
@@ -2373,7 +2478,7 @@ function internalResolveSelectionPoint(dom, offset) {
       if ($isElementNode(resolvedElement)) {
         let child = resolvedElement.getChildAtIndex(resolvedOffset);
 
-        if ($isElementNode(child)) {
+        if ($isElementNode(child) && shouldResolveAncestor(child, resolvedOffset, lastPoint)) {
           const descendant = moveSelectionToEnd ? child.getLastDescendant() : child.getFirstDescendant();
 
           if (descendant === null) {
@@ -2395,11 +2500,6 @@ function internalResolveSelectionPoint(dom, offset) {
       } else {
         resolvedOffset = resolvedElement.getIndexWithinParent() + 1;
         resolvedElement = resolvedElement.getParentOrThrow();
-      } // You can't select root nodes
-
-
-      if ($isRootNode(resolvedElement)) {
-        return null;
       }
 
       if ($isElementNode(resolvedElement)) {
@@ -2418,18 +2518,18 @@ function internalResolveSelectionPoint(dom, offset) {
   return $createPoint(resolvedNode.__key, resolvedOffset, 'text');
 }
 
-function internalResolveSelectionPoints(anchorDOM, anchorOffset, focusDOM, focusOffset, editor) {
+function internalResolveSelectionPoints(anchorDOM, anchorOffset, focusDOM, focusOffset, editor, lastSelection) {
   if (anchorDOM === null || focusDOM === null || !isSelectionWithinEditor(editor, anchorDOM, focusDOM)) {
     return null;
   }
 
-  const resolvedAnchorPoint = internalResolveSelectionPoint(anchorDOM, anchorOffset);
+  const resolvedAnchorPoint = internalResolveSelectionPoint(anchorDOM, anchorOffset, lastSelection !== null ? lastSelection.anchor : null);
 
   if (resolvedAnchorPoint === null) {
     return null;
   }
 
-  const resolvedFocusPoint = internalResolveSelectionPoint(focusDOM, focusOffset);
+  const resolvedFocusPoint = internalResolveSelectionPoint(focusDOM, focusOffset, lastSelection !== null ? lastSelection.focus : null);
 
   if (resolvedFocusPoint === null) {
     return null;
@@ -2467,9 +2567,6 @@ function internalResolveSelectionPoints(anchorDOM, anchorOffset, focusDOM, focus
       }
     }
 
-    const currentEditorState = editor.getEditorState();
-    const lastSelection = currentEditorState._selection;
-
     if (editor.isComposing() && editor._compositionKey !== resolvedAnchorPoint.key && lastSelection !== null) {
       const lastAnchor = lastSelection.anchor;
       const lastFocus = lastSelection.focus;
@@ -2542,7 +2639,7 @@ function internalCreateRangeSelection(editor) {
   // native selection.
 
 
-  const resolvedSelectionPoints = internalResolveSelectionPoints(anchorDOM, anchorOffset, focusDOM, focusOffset, editor);
+  const resolvedSelectionPoints = internalResolveSelectionPoints(anchorDOM, anchorOffset, focusDOM, focusOffset, editor, lastSelection);
 
   if (resolvedSelectionPoints === null) {
     return null;
@@ -2797,7 +2894,7 @@ function removeNode(nodeToRemove, restoreSelection) {
     }
   }
 
-  $internallyMarkSiblingsAsDirty(nodeToRemove);
+  internalMarkSiblingsAsDirty(nodeToRemove);
   parentChildren.splice(index, 1);
   const writableNodeToRemove = nodeToRemove.getWritable();
   writableNodeToRemove.__parent = null;
@@ -2830,8 +2927,8 @@ class LexicalNode {
 
   constructor(key) {
     this.__type = this.constructor.getType();
-    this.__key = key || $generateKey(this);
-    this.__parent = null; // Ensure custom nodes implement required methods.
+    this.__parent = null;
+    $setNodeKey(this, key); // Ensure custom nodes implement required methods.
 
     {
       const proto = Object.getPrototypeOf(this);
@@ -3269,7 +3366,7 @@ class LexicalNode {
 
     if (cloneNotNeeded.has(key)) {
       // Transforms clear the dirty node set on each iteration to keep track on newly dirty nodes
-      $internallyMarkNodeAsDirty(latestNode);
+      internalMarkNodeAsDirty(latestNode);
       return latestNode;
     }
 
@@ -3293,7 +3390,7 @@ class LexicalNode {
 
     cloneNotNeeded.add(key);
     mutableNode.__key = key;
-    $internallyMarkNodeAsDirty(mutableNode); // Update reference in node map
+    internalMarkNodeAsDirty(mutableNode); // Update reference in node map
 
     nodeMap.set(key, mutableNode); // $FlowFixMe this is LexicalNode
 
@@ -3349,7 +3446,7 @@ class LexicalNode {
         }
       }
 
-      $internallyMarkSiblingsAsDirty(writableReplaceWith);
+      internalMarkSiblingsAsDirty(writableReplaceWith);
       children.splice(index, 1);
     }
 
@@ -3368,7 +3465,7 @@ class LexicalNode {
     children.splice(index, 0, newKey);
     writableReplaceWith.__parent = newParent.__key;
     removeNode(this, false);
-    $internallyMarkSiblingsAsDirty(writableReplaceWith);
+    internalMarkSiblingsAsDirty(writableReplaceWith);
     const selection = $getSelection();
 
     if (selection !== null) {
@@ -3411,7 +3508,7 @@ class LexicalNode {
         }
       }
 
-      $internallyMarkSiblingsAsDirty(writableNodeToInsert);
+      internalMarkSiblingsAsDirty(writableNodeToInsert);
 
       if (selection !== null) {
         const oldParentKey = oldParent.getKey();
@@ -3438,7 +3535,7 @@ class LexicalNode {
     }
 
     children.splice(index + 1, 0, insertKey);
-    $internallyMarkSiblingsAsDirty(writableNodeToInsert);
+    internalMarkSiblingsAsDirty(writableNodeToInsert);
 
     if (selection !== null) {
       $updateElementSelectionOnCreateDeleteNode(selection, writableParent, index + 1);
@@ -3473,7 +3570,7 @@ class LexicalNode {
         }
       }
 
-      $internallyMarkSiblingsAsDirty(writableNodeToInsert);
+      internalMarkSiblingsAsDirty(writableNodeToInsert);
       children.splice(index, 1);
     }
 
@@ -3490,7 +3587,7 @@ class LexicalNode {
     }
 
     children.splice(index, 0, insertKey);
-    $internallyMarkSiblingsAsDirty(writableNodeToInsert);
+    internalMarkSiblingsAsDirty(writableNodeToInsert);
     const selection = $getSelection();
 
     if (selection !== null) {
@@ -3605,7 +3702,7 @@ class DecoratorEditor {
 
       if (editorState !== null) {
         editor.setEditorState(editorState, {
-          tag: 'without-history'
+          tag: 'history-merge'
         });
       }
     }
@@ -3792,6 +3889,14 @@ class DecoratorNode extends LexicalNode {
     }
   }
 
+  isIsolated() {
+    return false;
+  }
+
+  isTopLevel() {
+    return false;
+  }
+
 }
 function $isDecoratorNode(node) {
   return node instanceof DecoratorNode;
@@ -3960,6 +4065,7 @@ let subTreeDirectionedTextContent = '';
 let editorTextContent = '';
 let activeEditorConfig;
 let activeEditor$1;
+let activeEditorNodes;
 let treatAllNodesAsDirty = false;
 let activeEditorStateReadOnly = false;
 let activeTextDirection = null;
@@ -3968,6 +4074,7 @@ let activeDirtyLeaves;
 let activePrevNodeMap;
 let activeNextNodeMap;
 let activePrevKeyToDOMMap;
+let mutatedNodes;
 
 function destroyNode(key, parentDOM) {
   const node = activePrevNodeMap.get(key);
@@ -3987,6 +4094,10 @@ function destroyNode(key, parentDOM) {
     const children = node.__children;
     destroyChildren(children, 0, children.length - 1, null);
   }
+
+  if (node !== undefined) {
+    setMutatedNode(mutatedNodes, activeEditorNodes, node, 'destroyed');
+  }
 }
 
 function destroyChildren(children, _startIndex, endIndex, dom) {
@@ -4123,6 +4234,7 @@ function createNode(key, parentDOM, insertDOM) {
     Object.freeze(node);
   }
 
+  setMutatedNode(mutatedNodes, activeEditorNodes, node, 'created');
   return dom;
 }
 
@@ -4512,12 +4624,15 @@ function reconcileRoot(prevEditorState, nextEditorState, editor, selection, dirt
   activeTextDirection = null;
   activeEditor$1 = editor;
   activeEditorConfig = editor._config;
+  activeEditorNodes = editor._nodes;
   activeDirtyElements = dirtyElements;
   activeDirtyLeaves = dirtyLeaves;
   activePrevNodeMap = prevEditorState._nodeMap;
   activeNextNodeMap = nextEditorState._nodeMap;
   activeEditorStateReadOnly = nextEditorState._readOnly;
   activePrevKeyToDOMMap = new Map(editor._keyToDOMMap);
+  const currentMutatedNodes = new Map();
+  mutatedNodes = currentMutatedNodes;
   reconcileNode('root', null); // We don't want a bunch of void checks throughout the scope
   // so instead we make it seem that these values are always set.
   // We also want to make sure we clear them down, otherwise we
@@ -4526,6 +4641,8 @@ function reconcileRoot(prevEditorState, nextEditorState, editor, selection, dirt
 
   activeEditor$1 = undefined; // $FlowFixMe
 
+  activeEditorNodes = undefined; // $FlowFixMe
+
   activeDirtyElements = undefined; // $FlowFixMe
 
   activeDirtyLeaves = undefined; // $FlowFixMe
@@ -4536,11 +4653,15 @@ function reconcileRoot(prevEditorState, nextEditorState, editor, selection, dirt
 
   activeEditorConfig = undefined; // $FlowFixMe
 
-  activePrevKeyToDOMMap = undefined;
+  activePrevKeyToDOMMap = undefined; // $FlowFixMe
+
+  mutatedNodes = undefined;
+  return currentMutatedNodes;
 }
 
 function updateEditorState(rootElement, currentEditorState, pendingEditorState, currentSelection, pendingSelection, needsUpdate, editor) {
   const observer = editor._observer;
+  let reconcileMutatedNodes = null;
 
   if (needsUpdate && observer !== null) {
     const dirtyType = editor._dirtyType;
@@ -4549,7 +4670,7 @@ function updateEditorState(rootElement, currentEditorState, pendingEditorState,
     observer.disconnect();
 
     try {
-      reconcileRoot(currentEditorState, pendingEditorState, editor, pendingSelection, dirtyType, dirtyElements, dirtyLeaves);
+      reconcileMutatedNodes = reconcileRoot(currentEditorState, pendingEditorState, editor, pendingSelection, dirtyType, dirtyElements, dirtyLeaves);
     } finally {
       observer.observe(rootElement, {
         characterData: true,
@@ -4564,6 +4685,8 @@ function updateEditorState(rootElement, currentEditorState, pendingEditorState,
   if (domSelection !== null && (needsUpdate || pendingSelection === null || pendingSelection.dirty)) {
     reconcileSelection(currentSelection, pendingSelection, editor, domSelection);
   }
+
+  return reconcileMutatedNodes;
 }
 
 function scrollIntoViewIfNeeded(node, rootElement) {
@@ -4979,19 +5102,20 @@ function commitPendingUpdates(editor) {
   editor._updating = true;
 
   try {
-    updateEditorState(rootElement, currentEditorState, pendingEditorState, currentSelection, pendingSelection, needsUpdate, editor);
+    const mutatedNodes = updateEditorState(rootElement, currentEditorState, pendingEditorState, currentSelection, pendingSelection, needsUpdate, editor);
+
+    if (mutatedNodes !== null) {
+      triggerMutationListeners(editor, currentEditorState, pendingEditorState, mutatedNodes);
+    }
   } catch (error) {
     // Report errors
-    triggerListeners('error', editor, false, error, error._log); // Reset editor and restore incoming editor state to the DOM
+    triggerListeners('error', editor, false, error); // Reset editor and restore incoming editor state to the DOM
 
     if (!isAttemptingToRecoverFromReconcilerError) {
       resetEditor(editor, null, rootElement, pendingEditorState);
       initMutationObserver(editor);
       editor._dirtyType = FULL_RECONCILE;
       isAttemptingToRecoverFromReconcilerError = true;
-
-      editor._log.push('ReconcileRecover');
-
       commitPendingUpdates(editor);
       isAttemptingToRecoverFromReconcilerError = false;
     }
@@ -5014,8 +5138,6 @@ function commitPendingUpdates(editor) {
   const dirtyElements = editor._dirtyElements;
   const normalizedNodes = editor._normalizedNodes;
   const tags = editor._updateTags;
-  const log = editor._log;
-  editor._log = [];
 
   if (needsUpdate) {
     editor._dirtyType = NO_DIRTY_NODES;
@@ -5042,7 +5164,6 @@ function commitPendingUpdates(editor) {
     dirtyElements,
     dirtyLeaves,
     editorState: pendingEditorState,
-    log,
     normalizedNodes,
     prevEditorState: currentEditorState,
     tags
@@ -5060,6 +5181,19 @@ function triggerTextContentListeners(editor, currentEditorState, pendingEditorSt
   }
 }
 
+function triggerMutationListeners(editor, currentEditorState, pendingEditorState, mutatedNodes) {
+  const listeners = editor._listeners.mutation;
+  listeners.forEach((klass, listener) => {
+    const mutatedNodesByType = mutatedNodes.get(klass);
+
+    if (mutatedNodesByType === undefined) {
+      return;
+    }
+
+    listener(mutatedNodesByType);
+  });
+}
+
 function triggerListeners(type, editor, isCurrentlyEnqueuingUpdates, // $FlowFixMe: needs refining
 ...payload) {
   const previouslyUpdating = editor._updating;
@@ -5108,7 +5242,7 @@ function triggerEnqueuedUpdates(editor) {
 
   if (queuedUpdates.length !== 0) {
     const [updateFn, options] = queuedUpdates.shift();
-    beginUpdate(editor, updateFn, false, options);
+    beginUpdate(editor, updateFn, options);
   }
 }
 
@@ -5164,7 +5298,7 @@ function processNestedUpdates(editor) {
   return skipTransforms;
 }
 
-function beginUpdate(editor, updateFn, skipEmptyCheck, options) {
+function beginUpdate(editor, updateFn, options) {
   const updateTags = editor._updateTags;
   let onUpdate;
   let tag;
@@ -5214,12 +5348,6 @@ function beginUpdate(editor, updateFn, skipEmptyCheck, options) {
     applySelectionTransforms(pendingEditorState, editor);
 
     if (editor._dirtyType !== NO_DIRTY_NODES) {
-      if (!skipEmptyCheck && pendingEditorState.isEmpty()) {
-        {
-          throw Error(`updateEditor: the pending editor state is empty. Ensure the root not never becomes empty from an update.`);
-        }
-      }
-
       if (skipTransforms) {
         $normalizeAllDirtyTextNodes(pendingEditorState, editor);
       } else {
@@ -5251,7 +5379,7 @@ function beginUpdate(editor, updateFn, skipEmptyCheck, options) {
     }
   } catch (error) {
     // Report errors
-    triggerListeners('error', editor, false, error, editor._log); // Restore existing editor state to the DOM
+    triggerListeners('error', editor, false, error); // Restore existing editor state to the DOM
 
     editor._pendingEditorState = currentEditorState;
     editor._dirtyType = FULL_RECONCILE;
@@ -5262,8 +5390,6 @@ function beginUpdate(editor, updateFn, skipEmptyCheck, options) {
 
     editor._dirtyElements.clear();
 
-    editor._log.push('UpdateRecover');
-
     commitPendingUpdates(editor);
     return;
   } finally {
@@ -5296,11 +5422,11 @@ function beginUpdate(editor, updateFn, skipEmptyCheck, options) {
   }
 }
 
-function updateEditor(editor, updateFn, skipEmptyCheck, options) {
+function updateEditor(editor, updateFn, options) {
   if (editor._updating) {
     editor._updates.push([updateFn, options]);
   } else {
-    beginUpdate(editor, updateFn, skipEmptyCheck, options);
+    beginUpdate(editor, updateFn, options);
   }
 }
 
@@ -5592,7 +5718,7 @@ class ElementNode extends LexicalNode {
     const lastChild = this.getLastChild();
 
     if (lastChild !== null) {
-      $internallyMarkNodeAsDirty(lastChild);
+      internalMarkNodeAsDirty(lastChild);
     }
 
     for (let i = 0; i < nodesToAppendLength; i++) {
@@ -5683,7 +5809,7 @@ class ElementNode extends LexicalNode {
           }
         }
 
-        $internallyMarkSiblingsAsDirty(nodeToInsert);
+        internalMarkSiblingsAsDirty(nodeToInsert);
         children.splice(index, 1);
       } // Set child parent to self
 
@@ -5697,13 +5823,13 @@ class ElementNode extends LexicalNode {
     const nodeBeforeRange = this.getChildAtIndex(start - 1);
 
     if (nodeBeforeRange) {
-      $internallyMarkNodeAsDirty(nodeBeforeRange);
+      internalMarkNodeAsDirty(nodeBeforeRange);
     }
 
     const nodeAfterRange = this.getChildAtIndex(start + deleteCount);
 
     if (nodeAfterRange) {
-      $internallyMarkNodeAsDirty(nodeAfterRange);
+      internalMarkNodeAsDirty(nodeAfterRange);
     } // Remove defined range of children
 
 
@@ -5815,10 +5941,6 @@ class ElementNode extends LexicalNode {
     return false;
   }
 
-  canSelectionRemove() {
-    return true;
-  }
-
   canMergeWith(node) {
     return false;
   }
@@ -5850,6 +5972,12 @@ class RootNode extends ElementNode {
     this.__cachedText = null;
   }
 
+  getTopLevelElementOrThrow() {
+    {
+      throw Error(`getTopLevelElementOrThrow: root nodes are not top level elements`);
+    }
+  }
+
   getTextContent(includeInert, includeDirectionless) {
     const cachedText = this.__cachedText;
 
@@ -5862,22 +5990,13 @@ class RootNode extends ElementNode {
     return super.getTextContent(includeInert, includeDirectionless);
   }
 
-  select() {
-    // You can't select root nodes.
-    {
-      throw Error(`select: cannot be called on root nodes`);
-    }
-  }
-
   remove() {
-    // You can't select root nodes.
     {
       throw Error(`remove: cannot be called on root nodes`);
     }
   }
 
   replace(node) {
-    // You can't select root nodes.
     {
       throw Error(`replace: cannot be called on root nodes`);
     }
@@ -5915,10 +6034,6 @@ class RootNode extends ElementNode {
     return super.append(...nodesToAppend);
   }
 
-  canBeEmpty() {
-    return false;
-  }
-
 }
 function $createRootNode() {
   return new RootNode();
@@ -6023,27 +6138,14 @@ if (CAN_USE_BEFORE_INPUT) {
 }
 
 let lastKeyWasMaybeAndroidSoftKey = false;
+let rootElementsRegistered = 0;
 
-function onSelectionChange(editor) {
-  const domSelection = window.getSelection();
-  const parentEditors = getEditorsToPropagate(editor);
-  const topLevelEditor = parentEditors[parentEditors.length - 1];
-  const topLevelEditorElement = topLevelEditor.getRootElement(); // This is a hot-path, so let's avoid doing an update when
-  // the anchorNode is not actually inside the editor (or its parent).
-
-  if (topLevelEditorElement && !topLevelEditorElement.contains(domSelection.anchorNode)) {
-    return;
-  } // This update functions as a way of reconciling a bad selection
-  // to a good selection.
-
-
+function onSelectionChange(editor, isActive) {
   editor.update(() => {
-    $pushLogEntry('onSelectionChange'); // Non-active editor don't need any extra logic for selection, it only needs update
+    // Non-active editor don't need any extra logic for selection, it only needs update
     // to reconcile selection (set it to null) to ensure that only one editor has non-null selection.
-
-    const isActiveEditor = isSelectionWithinEditor(editor, domSelection.anchorNode, domSelection.focusNode);
-
-    if (!isActiveEditor) {
+    if (!isActive) {
+      $setSelection(null);
       return;
     }
 
@@ -6071,7 +6173,6 @@ function onSelectionChange(editor) {
 
 function onClick(event, editor) {
   editor.update(() => {
-    $pushLogEntry('onClick');
     const selection = $getSelection();
 
     if (selection === null) {
@@ -6113,7 +6214,6 @@ function onBeforeInput(event, editor) {
   }
 
   editor.update(() => {
-    $pushLogEntry('onBeforeInputForRichText');
     const selection = $getSelection();
 
     if (selection === null) {
@@ -6130,7 +6230,7 @@ function onBeforeInput(event, editor) {
 
     const data = event.data;
 
-    if (!selection.dirty && selection.isCollapsed()) {
+    if (!selection.dirty && selection.isCollapsed() && !$isRootNode(selection.anchor.getNode())) {
       $applyTargetRange(selection, event);
     }
 
@@ -6297,7 +6397,6 @@ function onInput(event, editor) {
   // We don't want the onInput to bubble, in the case of nested editors.
   event.stopPropagation();
   editor.update(() => {
-    $pushLogEntry('onInput');
     const selection = $getSelection();
     const data = event.data;
 
@@ -6315,7 +6414,6 @@ function onInput(event, editor) {
 
 function onCompositionStart(event, editor) {
   editor.update(() => {
-    $pushLogEntry('onCompositionStart');
     const selection = $getSelection();
 
     if (selection !== null && !editor.isComposing()) {
@@ -6335,7 +6433,6 @@ function onCompositionStart(event, editor) {
 
 function onCompositionEndInternal(event, editor) {
   editor.update(() => {
-    $pushLogEntry('onCompositionEnd');
     $setCompositionKey(null);
     $updateSelectedTextFromDOM(editor, true);
   });
@@ -6443,12 +6540,12 @@ function isRootEditable(editor) {
 
 function getRootElementRemoveHandles(rootElement) {
   // $FlowFixMe: internal field
-  let eventHandles = rootElement._lexicalEventHandles;
+  let eventHandles = rootElement.__lexicalEventHandles;
 
   if (eventHandles === undefined) {
     eventHandles = []; // $FlowFixMe: internal field
 
-    rootElement._lexicalEventHandles = eventHandles;
+    rootElement.__lexicalEventHandles = eventHandles;
   }
 
   return eventHandles;
@@ -6457,7 +6554,11 @@ function getRootElementRemoveHandles(rootElement) {
 function clearRootElementRemoveHandles(rootElement) {
   // $FlowFixMe: internal field
   rootElement._lexicalEventHandles = [];
-}
+} // Mapping root editors to their active nested editors, contains nested editors
+// mapping only, so if root editor is selected map will have no reference to free up memory
+
+
+const activeNestedEditorsMap = new Map();
 
 function onDocumentSelectionChange(event) {
   const sel = window.getSelection();
@@ -6465,10 +6566,31 @@ function onDocumentSelectionChange(event) {
 
   while (node != null) {
     if (node.contentEditable === 'true') {
-      const possibleLexicalEditor = node.__lexicalEditor;
+      const nextActiveEditor = node.__lexicalEditor;
+
+      if (nextActiveEditor !== undefined) {
+        // When editor receives selection change event, we're checking if
+        // it has any sibling editors (within same parent editor) that were active
+        // before, and trigger selection change on it to nullify selection.
+        const editors = getEditorsToPropagate(nextActiveEditor);
+        const rootEditor = editors[editors.length - 1];
+        const rootEditorKey = rootEditor._key;
+        const activeNestedEditor = activeNestedEditorsMap.get(rootEditorKey);
+        const prevActiveEditor = activeNestedEditor || rootEditor;
+
+        if (prevActiveEditor !== nextActiveEditor) {
+          onSelectionChange(prevActiveEditor, false);
+        }
+
+        onSelectionChange(nextActiveEditor, true); // If newly selected editor is nested, then add it to the map, clean map otherwise
 
-      if (possibleLexicalEditor !== undefined) {
-        onSelectionChange(possibleLexicalEditor);
+        if (nextActiveEditor !== rootEditor) {
+          activeNestedEditorsMap.set(rootEditorKey, nextActiveEditor);
+        } else if (activeNestedEditor) {
+          activeNestedEditorsMap.delete(rootEditorKey);
+        }
+
+        return;
       }
     }
 
@@ -6476,18 +6598,17 @@ function onDocumentSelectionChange(event) {
   }
 }
 
-function addDocumentSelectionChangeEvent(rootElement, editor) {
-  const doc = rootElement.ownerDocument; // $FlowFixMe: internal field
-
-  rootElement.__lexicalEditor = editor; // $FlowFixMe: internal field
-
-  if (doc._lexicalEvent === undefined) {
-    // $FlowFixMe: internal field
-    doc._lexicalEvent = true;
+function addRootElementEvents(rootElement, editor) {
+  // We only want to have a single global selectionchange event handler, shared
+  // between all editor instances.
+  if (rootElementsRegistered === 0) {
+    const doc = rootElement.ownerDocument;
     doc.addEventListener('selectionchange', onDocumentSelectionChange);
   }
-}
-function addRootElementEvents(rootElement, editor) {
+
+  rootElementsRegistered++; // $FlowFixMe: internal field
+
+  rootElement.__lexicalEditor = editor;
   const removeHandles = getRootElementRemoveHandles(rootElement);
 
   for (let i = 0; i < rootElementEvents.length; i++) {
@@ -6508,7 +6629,17 @@ function addRootElementEvents(rootElement, editor) {
   }
 }
 function removeRootElementEvents(rootElement) {
-  // $FlowFixMe: internal field
+  rootElementsRegistered--; // We only want to have a single global selectionchange event handler, shared
+  // between all editor instances.
+
+  if (rootElementsRegistered === 0) {
+    const doc = rootElement.ownerDocument;
+    doc.removeEventListener('selectionchange', onDocumentSelectionChange);
+  } // $FlowFixMe: internal field
+
+
+  cleanActiveNestedEditorsMap(rootElement.__lexicalEditor); // $FlowFixMe: internal field
+
   rootElement.__lexicalEditor = null;
   const removeHandles = getRootElementRemoveHandles(rootElement);
 
@@ -6519,43 +6650,21 @@ function removeRootElementEvents(rootElement) {
   clearRootElementRemoveHandles(rootElement);
 }
 
-/**
- * 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.
- *
- * 
- */
-class HorizontalRuleNode extends LexicalNode {
-  static getType() {
-    return 'horizontal-rule';
-  }
-
-  static clone(node) {
-    return new HorizontalRuleNode(node.__key);
-  }
-
-  constructor(key) {
-    super(key);
-  }
-
-  createDOM() {
-    const element = document.createElement('hr');
-    element.setAttribute('contenteditable', 'false');
-    return element;
-  }
+function cleanActiveNestedEditorsMap(editor) {
+  // $FlowFixMe: internal field
+  if (editor._parentEditor) {
+    // For nested editor cleanup map if this editor was marked as active
+    const editors = getEditorsToPropagate(editor);
+    const rootEditor = editors[editors.length - 1];
+    const rootEditorKey = rootEditor._key;
 
-  updateDOM() {
-    return false;
+    if (activeNestedEditorsMap.get(rootEditorKey) === editor) {
+      activeNestedEditorsMap.delete(rootEditorKey);
+    }
+  } else {
+    // For top-level editors cleanup map
+    activeNestedEditorsMap.delete(editor._key);
   }
-
-}
-function $createHorizontalRuleNode() {
-  return new HorizontalRuleNode();
-}
-function $isHorizontalRuleNode(node) {
-  return node instanceof HorizontalRuleNode;
 }
 
 /**
@@ -6685,7 +6794,25 @@ function setTextThemeClassNames(tag, prevFormat, nextFormat, dom, textClassNames
   }
 }
 
+function diffComposedText(a, b) {
+  const aLength = a.length;
+  const bLength = b.length;
+  let left = 0;
+  let right = 0;
+
+  while (left < aLength && left < bLength && a[left] === b[left]) {
+    left++;
+  }
+
+  while (right + left < aLength && right + left < bLength && a[aLength - right - 1] === b[bLength - right - 1]) {
+    right++;
+  }
+
+  return [left, aLength - left - right, b.slice(left, bLength - right)];
+}
+
 function setTextContent(nextText, dom, node) {
+  // $FlowFixMe: first node is always text
   const firstChild = dom.firstChild;
   const isComposing = node.isComposing(); // Always add a suffix if we're composing a node
 
@@ -6694,8 +6821,19 @@ function setTextContent(nextText, dom, node) {
 
   if (firstChild == null) {
     dom.textContent = text;
-  } else if (firstChild.nodeValue !== text) {
-    firstChild.nodeValue = text;
+  } else {
+    const nodeValue = firstChild.nodeValue;
+    if (nodeValue !== text) if (isComposing) {
+      const [index, remove, insert] = diffComposedText(nodeValue, text);
+
+      if (remove !== 0) {
+        firstChild.deleteData(index, remove);
+      }
+
+      firstChild.insertData(index, insert);
+    } else {
+      firstChild.nodeValue = text;
+    }
   }
 }
 
@@ -7097,7 +7235,7 @@ class TextNode extends LexicalNode {
     } // Insert the nodes into the parent's children
 
 
-    $internallyMarkSiblingsAsDirty(this);
+    internalMarkSiblingsAsDirty(this);
     const writableParent = parent.getWritable();
     const writableParentChildren = writableParent.__children;
     const insertionIndex = writableParentChildren.indexOf(key);
@@ -7215,21 +7353,25 @@ class ParagraphNode extends ElementNode {
   }
 
   collapseAtStart() {
-    const children = this.getChildren();
-    const sibling = this.getNextSibling(); // If we have an empty (trimmed) first paragraph and try and remove it,
+    const children = this.getChildren(); // If we have an empty (trimmed) first paragraph and try and remove it,
     // delete the paragraph as long as we have another sibling to go to
 
-    if ($isElementNode(sibling) && this.getIndexWithinParent() === 0 && (children.length === 0 || $isTextNode(children[0]) && children[0].getTextContent().trim() === '')) {
-      const firstChild = sibling.getFirstChild();
+    if (children.length === 0 || $isTextNode(children[0]) && children[0].getTextContent().trim() === '') {
+      const nextSibling = this.getNextSibling();
 
-      if ($isTextNode(firstChild)) {
-        firstChild.select(0, 0);
-      } else {
-        sibling.select(0, 0);
+      if (nextSibling !== null) {
+        this.selectNext();
+        this.remove();
+        return true;
       }
 
-      this.remove();
-      return true;
+      const prevSibling = this.getPreviousSibling();
+
+      if (prevSibling !== null) {
+        this.selectPrevious();
+        this.remove();
+        return true;
+      }
     }
 
     return false;
@@ -7267,7 +7409,6 @@ function resetEditor(editor, prevRootElement, nextRootElement, pendingEditorStat
 
   editor._normalizedNodes = new Set();
   editor._updateTags = new Set();
-  editor._log = [];
   editor._updates = [];
   const observer = editor._observer;
 
@@ -7296,7 +7437,7 @@ function createEditor(editorConfig) {
   const disableEvents = config.disableEvents || false;
   const editorState = createEmptyEditorState();
   const initialEditorState = config.editorState;
-  const nodes = [RootNode, TextNode, HorizontalRuleNode, LineBreakNode, ParagraphNode, ...(config.nodes || [])];
+  const nodes = [RootNode, TextNode, LineBreakNode, ParagraphNode, ...(config.nodes || [])];
   const registeredNodes = new Map();
 
   for (let i = 0; i < nodes.length; i++) {
@@ -7353,9 +7494,9 @@ class BaseLexicalEditor {
       command: [new Set(), new Set(), new Set(), new Set(), new Set()],
       decorator: new Set(),
       error: new Set(),
+      mutation: new Map(),
       root: new Set(),
       textcontent: new Set(),
-      textmutation: new Set(),
       update: new Set()
     }; // Editor configuration for theme/context.
 
@@ -7373,9 +7514,7 @@ class BaseLexicalEditor {
     this._normalizedNodes = new Set();
     this._updateTags = new Set(); // Handling of DOM mutations
 
-    this._observer = null; // Logging for updates
-
-    this._log = []; // Used for identifying owning editors
+    this._observer = null; // Used for identifying owning editors
 
     this._key = generateRandomKey();
   }
@@ -7384,27 +7523,50 @@ class BaseLexicalEditor {
     return this._compositionKey != null;
   }
 
-  addListener(type, listener, priority) {
+  addListener(type, arg1, arg2) {
     const listenerSetOrMap = this._listeners[type];
 
     if (type === 'command') {
+      // $FlowFixMe: TODO refine
+      const listener = arg1; // $FlowFixMe: TODO refine
+
+      const priority = arg2;
+
       if (priority === undefined) {
         {
           throw Error(`Listener for type "command" requires a "priority".`);
         }
-      } // $FlowFixMe: unsure how to csae this
+      } // $FlowFixMe: unsure how to cast this
 
 
       const commands = listenerSetOrMap;
-      const commandSet = commands[priority]; // $FlowFixMe: cast
-
+      const commandSet = commands[priority];
       commandSet.add(listener);
       return () => {
-        // $FlowFixMe: cast
         commandSet.delete(listener);
       };
+    } else if (type === 'mutation') {
+      // $FlowFixMe: refine
+      const klass = arg1; // $FlowFixMe: refine
+
+      const mutationListener = arg2;
+
+      const registeredNode = this._nodes.get(klass.getType());
+
+      if (registeredNode === undefined) {
+        {
+          throw Error(`Node ${klass.name} has not been registered. Ensure node has been passed to createEditor.`);
+        }
+      }
+
+      const mutations = this._listeners.mutation;
+      mutations.set(mutationListener, klass);
+      return () => {
+        mutations.delete(mutationListener);
+      };
     } else {
-      // $FlowFixMe: TODO refine this from the above types
+      const listener = arg1; // $FlowFixMe: TODO refine this from the above types
+
       listenerSetOrMap.add(listener);
       const isRootType = type === 'root';
 
@@ -7497,12 +7659,11 @@ class BaseLexicalEditor {
         this._dirtyType = FULL_RECONCILE;
         initMutationObserver(getSelf(this));
 
-        this._updateTags.add('without-history');
+        this._updateTags.add('history-merge');
 
         commitPendingUpdates(getSelf(this)); // TODO: remove this flag once we no longer use UEv2 internally
 
         if (!this._config.disableEvents) {
-          addDocumentSelectionChangeEvent(nextRootElement, getSelf(this));
           addRootElementEvents(nextRootElement, getSelf(this));
         }
       }
@@ -7557,7 +7718,7 @@ class BaseLexicalEditor {
   }
 
   update(updateFn, options) {
-    updateEditor(getSelf(this), updateFn, false, options);
+    updateEditor(getSelf(this), updateFn, options);
   }
 
   focus(callbackFn) {
@@ -7576,7 +7737,7 @@ class BaseLexicalEditor {
         } else if (root.getChildrenSize() !== 0) {
           root.selectEnd();
         }
-      }, true, {
+      }, {
         onUpdate: () => {
           rootElement.removeAttribute('autocapitalize');
 
@@ -7600,13 +7761,11 @@ class BaseLexicalEditor {
 // For some reason, we can't do this via an interface without
 // Flow messing up the types. It's hacky, but it improves DX.
 
-exports.$createHorizontalRuleNode = $createHorizontalRuleNode;
 exports.$createLineBreakNode = $createLineBreakNode;
 exports.$createNodeFromParse = $createNodeFromParse;
 exports.$createParagraphNode = $createParagraphNode;
 exports.$createRangeSelection = $createEmptyRangeSelection;
 exports.$createTextNode = $createTextNode;
-exports.$getCompositionKey = $getCompositionKey;
 exports.$getNearestNodeFromDOMNode = $getNearestNodeFromDOMNode;
 exports.$getNodeByKey = $getNodeByKey;
 exports.$getPreviousSelection = $getPreviousSelection;
@@ -7614,14 +7773,12 @@ exports.$getRoot = $getRoot;
 exports.$getSelection = $getSelection;
 exports.$isDecoratorNode = $isDecoratorNode;
 exports.$isElementNode = $isElementNode;
-exports.$isHorizontalRuleNode = $isHorizontalRuleNode;
 exports.$isLeafNode = $isLeafNode;
 exports.$isLineBreakNode = $isLineBreakNode;
 exports.$isParagraphNode = $isParagraphNode;
 exports.$isRangeSelection = $isRangeSelection;
 exports.$isRootNode = $isRootNode;
 exports.$isTextNode = $isTextNode;
-exports.$log = $pushLogEntry;
 exports.$setCompositionKey = $setCompositionKey;
 exports.$setSelection = $setSelection;
 exports.DecoratorNode = DecoratorNode;