lexical 0.6.4 → 0.7.0

package/Lexical.dev.js

@@ -95,8 +95,8 @@ const CAN_USE_BEFORE_INPUT = CAN_USE_DOM && 'InputEvent' in window && !documentM
 const IS_SAFARI = CAN_USE_DOM && /Version\/[\d.]+.*Safari/.test(navigator.userAgent);
 const IS_IOS = CAN_USE_DOM && /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream; // Keep these in case we need to use them in the future.
 // export const IS_WINDOWS: boolean = CAN_USE_DOM && /Win/.test(navigator.platform);
-// export const IS_CHROME: boolean = CAN_USE_DOM && /^(?=.*Chrome).*/i.test(navigator.userAgent);
-// export const canUseTextInputEvent: boolean = CAN_USE_DOM && 'TextEvent' in window && !documentMode;
+
+const IS_CHROME = CAN_USE_DOM && /^(?=.*Chrome).*/i.test(navigator.userAgent); // export const canUseTextInputEvent: boolean = CAN_USE_DOM && 'TextEvent' in window && !documentMode;
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -133,7 +133,9 @@ const IS_UNMERGEABLE = 1 << 1; // Element node formatting
 const IS_ALIGN_LEFT = 1;
 const IS_ALIGN_CENTER = 2;
 const IS_ALIGN_RIGHT = 3;
-const IS_ALIGN_JUSTIFY = 4; // Reconciliation
+const IS_ALIGN_JUSTIFY = 4;
+const IS_ALIGN_START = 5;
+const IS_ALIGN_END = 6; // Reconciliation
 
 const NON_BREAKING_SPACE = '\u00A0';
 const ZERO_WIDTH_SPACE = '\u200b'; // For iOS/Safari we use a non breaking space, otherwise the cursor appears
@@ -165,15 +167,19 @@ const DETAIL_TYPE_TO_DETAIL = {
 };
 const ELEMENT_TYPE_TO_FORMAT = {
   center: IS_ALIGN_CENTER,
+  end: IS_ALIGN_END,
   justify: IS_ALIGN_JUSTIFY,
   left: IS_ALIGN_LEFT,
-  right: IS_ALIGN_RIGHT
+  right: IS_ALIGN_RIGHT,
+  start: IS_ALIGN_START
 };
 const ELEMENT_FORMAT_TO_TYPE = {
   [IS_ALIGN_CENTER]: 'center',
+  [IS_ALIGN_END]: 'end',
   [IS_ALIGN_JUSTIFY]: 'justify',
   [IS_ALIGN_LEFT]: 'left',
-  [IS_ALIGN_RIGHT]: 'right'
+  [IS_ALIGN_RIGHT]: 'right',
+  [IS_ALIGN_START]: 'start'
 };
 const TEXT_MODE_TO_TYPE = {
   normal: IS_NORMAL,
@@ -266,6 +272,7 @@ function $flushMutations$1(editor, mutations, observer) {
       // actually "on screen".
 
       const currentEditorState = editor._editorState;
+      const blockCursorElement = editor._blockCursorElement;
       let shouldRevertSelection = false;
       let possibleTextForFirefoxPaste = '';
 
@@ -298,7 +305,7 @@ function $flushMutations$1(editor, mutations, observer) {
             const node = getNodeFromDOMNode(addedDOM);
             const parentDOM = addedDOM.parentNode;
 
-            if (parentDOM != null && node === null && (addedDOM.nodeName !== 'BR' || !isManagedLineBreak(addedDOM, parentDOM, editor))) {
+            if (parentDOM != null && addedDOM !== blockCursorElement && node === null && (addedDOM.nodeName !== 'BR' || !isManagedLineBreak(addedDOM, parentDOM, editor))) {
               if (IS_FIREFOX) {
                 const possibleText = addedDOM.innerText || addedDOM.nodeValue;
 
@@ -320,7 +327,7 @@ function $flushMutations$1(editor, mutations, observer) {
             for (let s = 0; s < removedDOMsLength; s++) {
               const removedDOM = removedDOMs[s];
 
-              if (removedDOM.nodeName === 'BR' && isManagedLineBreak(removedDOM, targetDOM, editor)) {
+              if (removedDOM.nodeName === 'BR' && isManagedLineBreak(removedDOM, targetDOM, editor) || blockCursorElement === removedDOM) {
                 targetDOM.appendChild(removedDOM);
                 unremovedBRs++;
               }
@@ -344,7 +351,7 @@ function $flushMutations$1(editor, mutations, observer) {
       if (badDOMTargets.size > 0) {
         for (const [targetDOM, targetNode] of badDOMTargets) {
           if ($isElementNode(targetNode)) {
-            const childKeys = targetNode.__children;
+            const childKeys = targetNode.getChildrenKeys();
             let currentDOM = targetDOM.firstChild;
 
             for (let s = 0; s < childKeys.length; s++) {
@@ -455,19 +462,18 @@ const scheduleMicroTask = typeof queueMicrotask === 'function' ? queueMicrotask
 };
 function $isSelectionCapturedInDecorator(node) {
   return $isDecoratorNode($getNearestNodeFromDOMNode(node));
-} // TODO change to $ function
-
+}
 function isSelectionCapturedInDecoratorInput(anchorDOM) {
   const activeElement = document.activeElement;
   const nodeName = activeElement !== null ? activeElement.nodeName : null;
-  return !$isDecoratorNode($getNearestNodeFromDOMNode(anchorDOM)) || nodeName !== 'INPUT' && nodeName !== 'TEXTAREA';
+  return $isDecoratorNode($getNearestNodeFromDOMNode(anchorDOM)) && (nodeName === 'INPUT' || nodeName === 'TEXTAREA');
 }
 function isSelectionWithinEditor(editor, anchorDOM, focusDOM) {
   const rootElement = editor.getRootElement();
 
   try {
     return rootElement !== null && rootElement.contains(anchorDOM) && rootElement.contains(focusDOM) && // Ignore if selection is within nested editor
-    anchorDOM !== null && isSelectionCapturedInDecoratorInput(anchorDOM) && getNearestEditorFromDOMNode(anchorDOM) === editor;
+    anchorDOM !== null && !isSelectionCapturedInDecoratorInput(anchorDOM) && getNearestEditorFromDOMNode(anchorDOM) === editor;
   } catch (error) {
     return false;
   }
@@ -585,22 +591,61 @@ function internalMarkParentElementsAsDirty(parentKey, nodeMap, dirtyElements) {
   }
 }
 
-function removeFromParent(writableNode) {
-  const oldParent = writableNode.getParent();
+function removeFromParent(node) {
+  const oldParent = node.getParent();
 
   if (oldParent !== null) {
+    const writableNode = node.getWritable();
     const writableParent = oldParent.getWritable();
-    const children = writableParent.__children;
-    const index = children.indexOf(writableNode.__key);
+    const prevSibling = node.getPreviousSibling();
+    const nextSibling = node.getNextSibling(); // TODO: this function duplicates a bunch of operations, can be simplified.
 
-    if (index === -1) {
-      {
-        throw Error(`Node is not a child of its parent`);
+    if (prevSibling === null) {
+      if (nextSibling !== null) {
+        const writableNextSibling = nextSibling.getWritable();
+        writableParent.__first = nextSibling.__key;
+        writableNextSibling.__prev = null;
+      } else {
+        writableParent.__first = null;
+      }
+    } else {
+      const writablePrevSibling = prevSibling.getWritable();
+
+      if (nextSibling !== null) {
+        const writableNextSibling = nextSibling.getWritable();
+        writableNextSibling.__prev = writablePrevSibling.__key;
+        writablePrevSibling.__next = writableNextSibling.__key;
+      } else {
+        writablePrevSibling.__next = null;
+      }
+
+      writableNode.__prev = null;
+    }
+
+    if (nextSibling === null) {
+      if (prevSibling !== null) {
+        const writablePrevSibling = prevSibling.getWritable();
+        writableParent.__last = prevSibling.__key;
+        writablePrevSibling.__next = null;
+      } else {
+        writableParent.__last = null;
+      }
+    } else {
+      const writableNextSibling = nextSibling.getWritable();
+
+      if (prevSibling !== null) {
+        const writablePrevSibling = prevSibling.getWritable();
+        writablePrevSibling.__next = writableNextSibling.__key;
+        writableNextSibling.__prev = writablePrevSibling.__key;
+      } else {
+        writableNextSibling.__prev = null;
       }
+
+      writableNode.__next = null;
     }
 
-    internalMarkSiblingsAsDirty(writableNode);
-    children.splice(index, 1);
+    writableParent.__size--;
+    writableNode.__parent = null;
   }
 } // Never use this function directly! It will break
 // the cloning heuristic. Instead use node.getWritable().
@@ -1156,8 +1201,15 @@ function setMutatedNode(mutatedNodes, registeredNodes, mutationListeners, node,
     mutatedNodes.set(klass, mutatedNodesByType);
   }
 
-  if (!mutatedNodesByType.has(nodeKey)) {
-    mutatedNodesByType.set(nodeKey, mutation);
+  const prevMutation = mutatedNodesByType.get(nodeKey); // If the node has already been "destroyed", yet we are
+  // re-making it, then this means a move likely happened.
+  // We should change the mutation to be that of "updated"
+  // instead.
+
+  const isMove = prevMutation === 'destroyed' && mutation === 'created';
+
+  if (prevMutation === undefined || isMove) {
+    mutatedNodesByType.set(nodeKey, isMove ? 'updated' : mutation);
   }
 }
 function $nodesOfType(klass) {
@@ -1194,7 +1246,7 @@ function resolveElement(element, isBackward, focusOffset) {
   return block.getChildAtIndex(isBackward ? offset - 1 : offset);
 }
 
-function $getDecoratorNode(focus, isBackward) {
+function $getAdjacentNode(focus, isBackward) {
   const focusOffset = focus.offset;
 
   if (focus.type === 'element') {
@@ -1425,6 +1477,96 @@ function errorOnInsertTextNodeOnRoot(node, insertNode) {
   }
 }
 
+function createBlockCursorElement(editorConfig) {
+  const theme = editorConfig.theme;
+  const element = document.createElement('div');
+  element.contentEditable = 'false';
+  element.setAttribute('data-lexical-cursor', 'true');
+  let blockCursorTheme = theme.blockCursor;
+
+  if (blockCursorTheme !== undefined) {
+    if (typeof blockCursorTheme === 'string') {
+      const classNamesArr = blockCursorTheme.split(' '); // @ts-expect-error: intentional
+
+      blockCursorTheme = theme.blockCursor = classNamesArr;
+    }
+
+    if (blockCursorTheme !== undefined) {
+      element.classList.add(...blockCursorTheme);
+    }
+  }
+
+  return element;
+}
+
+function needsBlockCursor(node) {
+  return ($isDecoratorNode(node) || $isElementNode(node) && !node.canBeEmpty()) && !node.isInline();
+}
+
+function removeDOMBlockCursorElement(blockCursorElement, editor, rootElement) {
+  rootElement.style.removeProperty('caret-color');
+  editor._blockCursorElement = null;
+  const parentElement = blockCursorElement.parentElement;
+
+  if (parentElement !== null) {
+    parentElement.removeChild(blockCursorElement);
+  }
+}
+function updateDOMBlockCursorElement(editor, rootElement, nextSelection) {
+  let blockCursorElement = editor._blockCursorElement;
+
+  if ($isRangeSelection(nextSelection) && nextSelection.isCollapsed() && nextSelection.anchor.type === 'element' && rootElement.contains(document.activeElement)) {
+    const anchor = nextSelection.anchor;
+    const elementNode = anchor.getNode();
+    const offset = anchor.offset;
+    const elementNodeSize = elementNode.getChildrenSize();
+    let isBlockCursor = false;
+    let insertBeforeElement = null;
+
+    if (offset === elementNodeSize) {
+      const child = elementNode.getChildAtIndex(offset - 1);
+
+      if (needsBlockCursor(child)) {
+        isBlockCursor = true;
+      }
+    } else {
+      const child = elementNode.getChildAtIndex(offset);
+
+      if (needsBlockCursor(child)) {
+        const sibling = child.getPreviousSibling();
+
+        if (sibling === null || needsBlockCursor(sibling)) {
+          isBlockCursor = true;
+          insertBeforeElement = editor.getElementByKey(child.__key);
+        }
+      }
+    }
+
+    if (isBlockCursor) {
+      const elementDOM = editor.getElementByKey(elementNode.__key);
+
+      if (blockCursorElement === null) {
+        editor._blockCursorElement = blockCursorElement = createBlockCursorElement(editor._config);
+      }
+
+      rootElement.style.caretColor = 'transparent';
+
+      if (insertBeforeElement === null) {
+        elementDOM.appendChild(blockCursorElement);
+      } else {
+        elementDOM.insertBefore(blockCursorElement, insertBeforeElement);
+      }
+
+      return;
+    }
+  } // Remove cursor
+
+
+  if (blockCursorElement !== null) {
+    removeDOMBlockCursorElement(blockCursorElement, editor, rootElement);
+  }
+}
+
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -1451,12 +1593,10 @@ function $garbageCollectDetachedDecorators(editor, pendingEditorState) {
 }
 
 function $garbageCollectDetachedDeepChildNodes(node, parentKey, prevNodeMap, nodeMap, dirtyNodes) {
-  const children = node.__children;
-  const childrenLength = children.length;
+  let child = node.getFirstChild();
 
-  for (let i = 0; i < childrenLength; i++) {
-    const childKey = children[i];
-    const child = nodeMap.get(childKey);
+  while (child !== null) {
+    const childKey = child.__key;
 
     if (child !== undefined && child.__parent === parentKey) {
       if ($isElementNode(child)) {
@@ -1471,6 +1611,8 @@ function $garbageCollectDetachedDeepChildNodes(node, parentKey, prevNodeMap, nod
 
       nodeMap.delete(childKey);
     }
+
+    child = child.isAttached() ? child.getNextSibling() : null;
   }
 }
 
@@ -1637,7 +1779,10 @@ function destroyNode(key, parentDOM) {
 
   if (parentDOM !== null) {
     const dom = getPrevElementByKeyOrThrow(key);
-    parentDOM.removeChild(dom);
+
+    if (dom.parentNode === parentDOM) {
+      parentDOM.removeChild(dom);
+    }
   } // This logic is really important, otherwise we will leak DOM nodes
   // when their corresponding LexicalNodes are removed from the editor state.
 
@@ -1647,7 +1792,7 @@ function destroyNode(key, parentDOM) {
   }
 
   if ($isElementNode(node)) {
-    const children = node.__children;
+    const children = createChildrenArray(node, activePrevNodeMap);
     destroyChildren(children, 0, children.length - 1, null);
   }
 
@@ -1689,6 +1834,10 @@ function setElementFormat(dom, format) {
     setTextAlign(domStyle, 'right');
   } else if (format === IS_ALIGN_JUSTIFY) {
     setTextAlign(domStyle, 'justify');
+  } else if (format === IS_ALIGN_START) {
+    setTextAlign(domStyle, 'start');
+  } else if (format === IS_ALIGN_END) {
+    setTextAlign(domStyle, 'end');
   }
 }
 
@@ -1714,16 +1863,15 @@ function createNode(key, parentDOM, insertDOM) {
 
   if ($isElementNode(node)) {
     const indent = node.__indent;
+    const childrenSize = node.__size;
 
     if (indent !== 0) {
       setElementIndent(dom, indent);
     }
 
-    const children = node.__children;
-    const childrenLength = children.length;
-
-    if (childrenLength !== 0) {
-      const endIndex = childrenLength - 1;
+    if (childrenSize !== 0) {
+      const endIndex = childrenSize - 1;
+      const children = createChildrenArray(node, activeNextNodeMap);
       createChildrenWithDirection(children, endIndex, node, dom);
     }
 
@@ -1734,7 +1882,7 @@ function createNode(key, parentDOM, insertDOM) {
     }
 
     if (!node.isInline()) {
-      reconcileElementTerminatingLineBreak(null, children, dom);
+      reconcileElementTerminatingLineBreak(null, node, dom);
     }
 
     if ($textContentRequiresDoubleLinebreakAtEnd(node)) {
@@ -1809,16 +1957,15 @@ function createChildren(children, _startIndex, endIndex, dom, insertDOM) {
   subTreeTextContent = previousSubTreeTextContent + subTreeTextContent;
 }
 
-function isLastChildLineBreakOrDecorator(children, nodeMap) {
-  const childKey = children[children.length - 1];
+function isLastChildLineBreakOrDecorator(childKey, nodeMap) {
   const node = nodeMap.get(childKey);
   return $isLineBreakNode(node) || $isDecoratorNode(node) && node.isInline();
 } // If we end an element with a LineBreakNode, then we need to add an additional <br>
 
 
-function reconcileElementTerminatingLineBreak(prevChildren, nextChildren, dom) {
-  const prevLineBreak = prevChildren !== null && (prevChildren.length === 0 || isLastChildLineBreakOrDecorator(prevChildren, activePrevNodeMap));
-  const nextLineBreak = nextChildren !== null && (nextChildren.length === 0 || isLastChildLineBreakOrDecorator(nextChildren, activeNextNodeMap));
+function reconcileElementTerminatingLineBreak(prevElement, nextElement, dom) {
+  const prevLineBreak = prevElement !== null && (prevElement.__size === 0 || isLastChildLineBreakOrDecorator(prevElement.__last, activePrevNodeMap));
+  const nextLineBreak = nextElement.__size === 0 || isLastChildLineBreakOrDecorator(nextElement.__last, activeNextNodeMap);
 
   if (prevLineBreak) {
     if (!nextLineBreak) {
@@ -1901,53 +2048,78 @@ function reconcileBlockDirection(element, dom) {
   }
 }
 
-function reconcileChildrenWithDirection(prevChildren, nextChildren, element, dom) {
+function reconcileChildrenWithDirection(prevElement, nextElement, dom) {
   const previousSubTreeDirectionTextContent = subTreeDirectionedTextContent;
   subTreeDirectionedTextContent = '';
-  reconcileChildren(element, prevChildren, nextChildren, dom);
-  reconcileBlockDirection(element, dom);
+  reconcileChildren(prevElement, nextElement, dom);
+  reconcileBlockDirection(nextElement, dom);
   subTreeDirectionedTextContent = previousSubTreeDirectionTextContent;
 }
 
-function reconcileChildren(element, prevChildren, nextChildren, dom) {
+function createChildrenArray(element, nodeMap) {
+  const children = [];
+  let nodeKey = element.__first;
+
+  while (nodeKey !== null) {
+    const node = nodeMap.get(nodeKey);
+
+    if (node === undefined) {
+      {
+        throw Error(`createChildrenArray: node does not exist in nodeMap`);
+      }
+    }
+
+    children.push(nodeKey);
+    nodeKey = node.__next;
+  }
+
+  return children;
+}
+
+function reconcileChildren(prevElement, nextElement, dom) {
   const previousSubTreeTextContent = subTreeTextContent;
+  const prevChildrenSize = prevElement.__size;
+  const nextChildrenSize = nextElement.__size;
   subTreeTextContent = '';
-  const prevChildrenLength = prevChildren.length;
-  const nextChildrenLength = nextChildren.length;
 
-  if (prevChildrenLength === 1 && nextChildrenLength === 1) {
-    const prevChildKey = prevChildren[0];
-    const nextChildKey = nextChildren[0];
+  if (prevChildrenSize === 1 && nextChildrenSize === 1) {
+    const prevFirstChildKey = prevElement.__first;
+    const nextFrstChildKey = nextElement.__first;
 
-    if (prevChildKey === nextChildKey) {
-      reconcileNode(prevChildKey, dom);
+    if (prevFirstChildKey === nextFrstChildKey) {
+      reconcileNode(prevFirstChildKey, dom);
     } else {
-      const lastDOM = getPrevElementByKeyOrThrow(prevChildKey);
-      const replacementDOM = createNode(nextChildKey, null, null);
+      const lastDOM = getPrevElementByKeyOrThrow(prevFirstChildKey);
+      const replacementDOM = createNode(nextFrstChildKey, null, null);
       dom.replaceChild(replacementDOM, lastDOM);
-      destroyNode(prevChildKey, null);
+      destroyNode(prevFirstChildKey, null);
     }
-  } else if (prevChildrenLength === 0) {
-    if (nextChildrenLength !== 0) {
-      createChildren(nextChildren, 0, nextChildrenLength - 1, dom, null);
-    }
-  } else if (nextChildrenLength === 0) {
-    if (prevChildrenLength !== 0) {
-      // @ts-expect-error: internal field
-      const lexicalLineBreak = dom.__lexicalLineBreak;
-      const canUseFastPath = lexicalLineBreak == null;
-      destroyChildren(prevChildren, 0, prevChildrenLength - 1, canUseFastPath ? null : dom);
-
-      if (canUseFastPath) {
-        // Fast path for removing DOM nodes
-        dom.textContent = '';
+  } else {
+    const prevChildren = createChildrenArray(prevElement, activePrevNodeMap);
+    const nextChildren = createChildrenArray(nextElement, activeNextNodeMap);
+
+    if (prevChildrenSize === 0) {
+      if (nextChildrenSize !== 0) {
+        createChildren(nextChildren, 0, nextChildrenSize - 1, dom, null);
+      }
+    } else if (nextChildrenSize === 0) {
+      if (prevChildrenSize !== 0) {
+        // @ts-expect-error: internal field
+        const lexicalLineBreak = dom.__lexicalLineBreak;
+        const canUseFastPath = lexicalLineBreak == null;
+        destroyChildren(prevChildren, 0, prevChildrenSize - 1, canUseFastPath ? null : dom);
+
+        if (canUseFastPath) {
+          // Fast path for removing DOM nodes
+          dom.textContent = '';
+        }
       }
+    } else {
+      reconcileNodeChildren(prevChildren, nextChildren, prevChildrenSize, nextChildrenSize, dom);
     }
-  } else {
-    reconcileNodeChildren(prevChildren, nextChildren, prevChildrenLength, nextChildrenLength, element, dom);
   }
 
-  if ($textContentRequiresDoubleLinebreakAtEnd(element)) {
+  if ($textContentRequiresDoubleLinebreakAtEnd(nextElement)) {
     subTreeTextContent += DOUBLE_LINE_BREAK;
   } // @ts-expect-error: internal field
 
@@ -2036,15 +2208,11 @@ function reconcileNode(key, parentDOM) {
       setElementFormat(dom, nextFormat);
     }
 
-    const prevChildren = prevNode.__children;
-    const nextChildren = nextNode.__children;
-    const childrenAreDifferent = prevChildren !== nextChildren;
-
-    if (childrenAreDifferent || isDirty) {
-      reconcileChildrenWithDirection(prevChildren, nextChildren, nextNode, dom);
+    if (isDirty) {
+      reconcileChildrenWithDirection(prevNode, nextNode, dom);
 
       if (!$isRootNode(nextNode) && !nextNode.isInline()) {
-        reconcileElementTerminatingLineBreak(prevChildren, nextChildren, dom);
+        reconcileElementTerminatingLineBreak(prevNode, nextNode, dom);
       }
     }
 
@@ -2104,10 +2272,16 @@ function getFirstChild(element) {
 }
 
 function getNextSibling(element) {
-  return element.nextSibling;
+  let nextSibling = element.nextSibling;
+
+  if (nextSibling !== null && nextSibling === activeEditor$1._blockCursorElement) {
+    nextSibling = nextSibling.nextSibling;
+  }
+
+  return nextSibling;
 }
 
-function reconcileNodeChildren(prevChildren, nextChildren, prevChildrenLength, nextChildrenLength, element, dom) {
+function reconcileNodeChildren(prevChildren, nextChildren, prevChildrenLength, nextChildrenLength, dom) {
   const prevEndIndex = prevChildrenLength - 1;
   const nextEndIndex = nextChildrenLength - 1;
   let prevChildrenSet;
@@ -3071,7 +3245,9 @@ function addRootElementEvents(rootElement, editor) {
             return dispatchCommand(editor, FOCUS_COMMAND, event);
 
           case 'blur':
-            return dispatchCommand(editor, BLUR_COMMAND, event);
+            {
+              return dispatchCommand(editor, BLUR_COMMAND, event);
+            }
 
           case 'drop':
             return dispatchCommand(editor, DROP_COMMAND, event);
@@ -3885,10 +4061,10 @@ class RangeSelection {
           textNode.select();
 
           if (startOffset === 0) {
-            firstNode.insertBefore(textNode);
+            firstNode.insertBefore(textNode, false);
           } else {
             const [targetNode] = firstNode.splitText(startOffset);
-            targetNode.insertAfter(textNode);
+            targetNode.insertAfter(textNode, false);
           } // When composing, we need to adjust the anchor offset so that
           // we correctly replace that right range.
 
@@ -3939,7 +4115,7 @@ class RangeSelection {
         if ($isTextNode(lastNode) && !lastNode.isToken() && endOffset !== lastNode.getTextContentSize()) {
           if (lastNode.isSegmented()) {
             const textNode = $createTextNode(lastNode.getTextContent());
-            lastNode.replace(textNode);
+            lastNode.replace(textNode, false);
             lastNode = textNode;
           }
 
@@ -3982,7 +4158,7 @@ class RangeSelection {
         if (lastNodeChild.isAttached()) {
           if (!selectedNodesSet.has(lastNodeChild) || lastNodeChild.is(lastElementChild)) {
             if (!firstAndLastElementsAreEqual) {
-              insertionTarget.insertAfter(lastNodeChild);
+              insertionTarget.insertAfter(lastNodeChild, false);
             }
           } else {
             lastNodeChild.remove();
@@ -4027,7 +4203,7 @@ class RangeSelection {
       } else {
         const textNode = $createTextNode(text);
         textNode.select();
-        firstNode.replace(textNode);
+        firstNode.replace(textNode, false);
       } // Remove all selected nodes that haven't already been removed.
 
 
@@ -4364,7 +4540,7 @@ class RangeSelection {
         lastNode = node;
 
         if ($isDecoratorNode(node) && !node.isInline()) {
-          target = target.insertAfter(node);
+          target = target.insertAfter(node, false);
         } else if (!$isElementNode(node)) {
           const firstChild = target.getFirstChild();
 
@@ -4391,12 +4567,12 @@ class RangeSelection {
 
             target = node;
           } else {
-            target = target.insertAfter(node);
+            target = target.insertAfter(node, false);
           }
         }
       } else if (!$isElementNode(node) || $isElementNode(node) && node.isInline() || $isDecoratorNode(target) && !target.isInline()) {
         lastNode = node;
-        target = target.insertAfter(node);
+        target = target.insertAfter(node, false);
       } else {
         const nextTarget = target.getParentOrThrow(); // if we're inserting an Element after a LineBreak, we want to move the target to the parent
         // and remove the LineBreak so we don't have empty space.
@@ -4550,7 +4726,7 @@ class RangeSelection {
         paragraph.select();
 
         if (child !== null) {
-          child.insertBefore(paragraph);
+          child.insertBefore(paragraph, false);
         } else {
           currentElement.append(paragraph);
         }
@@ -4565,7 +4741,7 @@ class RangeSelection {
 
     if (anchorOffset === 0 && nodesToMoveLength > 0 && currentElement.isInline()) {
       const parent = currentElement.getParentOrThrow();
-      const newElement = parent.insertNewAfter(this);
+      const newElement = parent.insertNewAfter(this, false);
 
       if ($isElementNode(newElement)) {
         const children = parent.getChildren();
@@ -4578,7 +4754,7 @@ class RangeSelection {
       return;
     }
 
-    const newElement = currentElement.insertNewAfter(this);
+    const newElement = currentElement.insertNewAfter(this, false);
 
     if (newElement === null) {
       // Handle as a line break insertion
@@ -4710,7 +4886,7 @@ class RangeSelection {
     const anchor = this.anchor;
     const collapse = alter === 'move'; // Handle the selection movement around decorators.
 
-    const possibleNode = $getDecoratorNode(focus, isBackward);
+    const possibleNode = $getAdjacentNode(focus, isBackward);
 
     if ($isDecoratorNode(possibleNode) && !possibleNode.isIsolated()) {
       // Make it possible to move selection from range selection to
@@ -4765,6 +4941,16 @@ class RangeSelection {
 
     if (!domSelection) {
       return;
+    }
+
+    const editor = getActiveEditor();
+    const blockCursorElement = editor._blockCursorElement;
+    const rootElement = editor._rootElement; // Remove the block cursor element if it exists. This will ensure selection
+    // works as intended. If we leave it in the DOM all sorts of strange bugs
+    // occur. :/
+
+    if (rootElement !== null && blockCursorElement !== null && $isElementNode(possibleNode) && !possibleNode.isInline() && !possibleNode.canBeEmpty()) {
+      removeDOMBlockCursorElement(blockCursorElement, editor, rootElement);
     } // We use the DOM selection.modify API here to "tell" us what the selection
     // will be. We then use it to update the Lexical selection accordingly. This
     // is much more reliable than waiting for a beforeinput and using the ranges
@@ -4847,7 +5033,7 @@ class RangeSelection {
       } // Handle the deletion around decorators.
 
 
-      const possibleNode = $getDecoratorNode(focus, isBackward);
+      const possibleNode = $getAdjacentNode(focus, isBackward);
 
       if ($isDecoratorNode(possibleNode) && !possibleNode.isIsolated()) {
         // Make it possible to move selection from range selection to
@@ -5042,7 +5228,7 @@ function shouldResolveAncestor(resolvedElement, resolvedOffset, lastPoint) {
   return lastPoint === null || parent === null || !parent.canBeEmpty() || parent !== lastPoint.getNode();
 }
 
-function internalResolveSelectionPoint(dom, offset, lastPoint) {
+function internalResolveSelectionPoint(dom, offset, lastPoint, editor) {
   let resolvedOffset = offset;
   let resolvedNode; // If we have selection on an element, we will
   // need to figure out (using the offset) what text
@@ -5063,7 +5249,16 @@ function internalResolveSelectionPoint(dom, offset, lastPoint) {
       resolvedOffset = childNodesLength - 1;
     }
 
-    const childDOM = childNodes[resolvedOffset];
+    let childDOM = childNodes[resolvedOffset];
+    let hasBlockCursor = false;
+
+    if (childDOM === editor._blockCursorElement) {
+      childDOM = childNodes[resolvedOffset + 1];
+      hasBlockCursor = true;
+    } else if (editor._blockCursorElement !== null) {
+      resolvedOffset--;
+    }
+
     resolvedNode = getNodeFromDOM(childDOM);
 
     if ($isTextNode(resolvedNode)) {
@@ -5086,7 +5281,7 @@ function internalResolveSelectionPoint(dom, offset, lastPoint) {
             resolvedOffset = 0;
           } else {
             child = descendant;
-            resolvedElement = child.getParentOrThrow();
+            resolvedElement = $isElementNode(child) ? child : child.getParentOrThrow();
           }
         }
 
@@ -5094,7 +5289,7 @@ function internalResolveSelectionPoint(dom, offset, lastPoint) {
           resolvedNode = child;
           resolvedElement = null;
           resolvedOffset = getTextNodeOffset(child, moveSelectionToEnd);
-        } else if (child !== resolvedElement && moveSelectionToEnd) {
+        } else if (child !== resolvedElement && moveSelectionToEnd && !hasBlockCursor) {
           resolvedOffset++;
         }
       } else {
@@ -5203,13 +5398,13 @@ function internalResolveSelectionPoints(anchorDOM, anchorOffset, focusDOM, focus
     return null;
   }
 
-  const resolvedAnchorPoint = internalResolveSelectionPoint(anchorDOM, anchorOffset, $isRangeSelection(lastSelection) ? lastSelection.anchor : null);
+  const resolvedAnchorPoint = internalResolveSelectionPoint(anchorDOM, anchorOffset, $isRangeSelection(lastSelection) ? lastSelection.anchor : null, editor);
 
   if (resolvedAnchorPoint === null) {
     return null;
   }
 
-  const resolvedFocusPoint = internalResolveSelectionPoint(focusDOM, focusOffset, $isRangeSelection(lastSelection) ? lastSelection.focus : null);
+  const resolvedFocusPoint = internalResolveSelectionPoint(focusDOM, focusOffset, $isRangeSelection(lastSelection) ? lastSelection.focus : null, editor);
 
   if (resolvedFocusPoint === null) {
     return null;
@@ -5523,7 +5718,7 @@ function adjustPointOffsetForMergedSibling(point, isBefore, key, target, textLen
     point.offset -= 1;
   }
 }
-function updateDOMSelection(prevSelection, nextSelection, editor, domSelection, tags, rootElement) {
+function updateDOMSelection(prevSelection, nextSelection, editor, domSelection, tags, rootElement, dirtyLeavesCount) {
   const anchorDOMNode = domSelection.anchorNode;
   const focusDOMNode = domSelection.focusNode;
   const anchorOffset = domSelection.anchorOffset;
@@ -5531,7 +5726,7 @@ function updateDOMSelection(prevSelection, nextSelection, editor, domSelection,
   const activeElement = document.activeElement; // TODO: make this not hard-coded, and add another config option
   // that makes this configurable.
 
-  if (tags.has('collaboration') && activeElement !== rootElement) {
+  if (tags.has('collaboration') && activeElement !== rootElement || activeElement !== null && isSelectionCapturedInDecoratorInput(activeElement)) {
     return;
   }
 
@@ -5587,7 +5782,7 @@ function updateDOMSelection(prevSelection, nextSelection, editor, domSelection,
   if (anchorOffset === nextAnchorOffset && focusOffset === nextFocusOffset && anchorDOMNode === nextAnchorNode && focusDOMNode === nextFocusNode && // Badly interpreted range selection when collapsed - #1482
   !(domSelection.type === 'Range' && isCollapsed)) {
     // If the root element does not have focus, ensure it has focus
-    if (rootElement !== null && (activeElement === null || !rootElement.contains(activeElement))) {
+    if (activeElement === null || !rootElement.contains(activeElement)) {
       rootElement.focus({
         preventScroll: true
       });
@@ -5596,28 +5791,39 @@ function updateDOMSelection(prevSelection, nextSelection, editor, domSelection,
     if (anchor.type !== 'element') {
       return;
     }
-  } // Apply the updated selection to the DOM. Note: this will trigger
-  // a "selectionchange" event, although it will be asynchronous.
-
-
-  try {
-    domSelection.setBaseAndExtent(nextAnchorNode, nextAnchorOffset, nextFocusNode, nextFocusOffset);
-
-    if (!tags.has('skip-scroll-into-view') && nextSelection.isCollapsed() && rootElement !== null && rootElement === activeElement) {
-      const selectionTarget = nextSelection instanceof RangeSelection && nextSelection.anchor.type === 'element' ? nextAnchorNode.childNodes[nextAnchorOffset] || null : domSelection.rangeCount > 0 ? domSelection.getRangeAt(0) : null;
+  }
 
-      if (selectionTarget !== null) {
-        // @ts-ignore Text nodes do have getBoundingClientRect
-        const selectionRect = selectionTarget.getBoundingClientRect();
-        scrollIntoViewIfNeeded(editor, selectionRect, rootElement);
+  if (!tags.has('skip-scroll-into-view')) // Apply the updated selection to the DOM. Note: this will trigger
+    // a "selectionchange" event, although it will be asynchronous.
+    try {
+      // When updating more than 1000 nodes on Chrome, it's actually better to defer
+      // updating the selection till the next frame. This is because Chrome's
+      // Blink engine has hard limit on how many DOM nodes it can redraw in
+      // a single cycle, so keeping it to the next frame improves performance.
+      // The downside is that is makes the computation within Lexical more
+      // complex, as now, we've sync update the DOM, but selection no longer
+      // matches.
+      if (IS_CHROME && dirtyLeavesCount > 1000) {
+        window.requestAnimationFrame(() => domSelection.setBaseAndExtent(nextAnchorNode, nextAnchorOffset, nextFocusNode, nextFocusOffset));
+      } else {
+        domSelection.setBaseAndExtent(nextAnchorNode, nextAnchorOffset, nextFocusNode, nextFocusOffset);
       }
+    } catch (error) {// If we encounter an error, continue. This can sometimes
+      // occur with FF and there's no good reason as to why it
+      // should happen.
     }
 
-    markSelectionChangeFromDOMUpdate();
-  } catch (error) {// If we encounter an error, continue. This can sometimes
-    // occur with FF and there's no good reason as to why it
-    // should happen.
+  if (!tags.has('skip-scroll-into-view') && nextSelection.isCollapsed() && rootElement !== null && rootElement === document.activeElement) {
+    const selectionTarget = nextSelection instanceof RangeSelection && nextSelection.anchor.type === 'element' ? nextAnchorNode.childNodes[nextAnchorOffset] || null : domSelection.rangeCount > 0 ? domSelection.getRangeAt(0) : null;
+
+    if (selectionTarget !== null) {
+      // @ts-ignore Text nodes do have getBoundingClientRect
+      const selectionRect = selectionTarget.getBoundingClientRect();
+      scrollIntoViewIfNeeded(editor, selectionRect, rootElement);
+    }
   }
+
+  markSelectionChangeFromDOMUpdate();
 }
 function $insertNodes(nodes, selectStart) {
   let selection = $getSelection();
@@ -5650,6 +5856,11 @@ let activeEditor = null;
 let isReadOnlyMode = false;
 let isAttemptingToRecoverFromReconcilerError = false;
 let infiniteTransformCount = 0;
+const observerOptions = {
+  characterData: true,
+  childList: true,
+  subtree: true
+};
 function isCurrentlyReadOnlyMode() {
   return isReadOnlyMode;
 }
@@ -5930,9 +6141,9 @@ function handleDEVOnlyPendingUpdateGuarantees(pendingEditorState) {
 function commitPendingUpdates(editor) {
   const pendingEditorState = editor._pendingEditorState;
   const rootElement = editor._rootElement;
-  const headless = editor._headless;
+  const shouldSkipDOM = editor._headless || rootElement === null;
 
-  if (rootElement === null && !headless || pendingEditorState === null) {
+  if (pendingEditorState === null) {
     return;
   } // ======
   // Reconciliation has started.
@@ -5952,7 +6163,7 @@ function commitPendingUpdates(editor) {
   editor._pendingEditorState = null;
   editor._editorState = pendingEditorState;
 
-  if (!headless && needsUpdate && observer !== null) {
+  if (!shouldSkipDOM && needsUpdate && observer !== null) {
     activeEditor = editor;
     activeEditorState = pendingEditorState;
     isReadOnlyMode = false; // We don't want updates to sync block the reconciliation.
@@ -5986,11 +6197,7 @@ function commitPendingUpdates(editor) {
 
       return;
     } finally {
-      observer.observe(rootElement, {
-        characterData: true,
-        childList: true,
-        subtree: true
-      });
+      observer.observe(rootElement, observerOptions);
       editor._updating = previouslyUpdating;
       activeEditorState = previousActiveEditorState;
       isReadOnlyMode = previousReadOnlyMode;
@@ -6018,6 +6225,7 @@ function commitPendingUpdates(editor) {
   const normalizedNodes = editor._normalizedNodes;
   const tags = editor._updateTags;
   const deferred = editor._deferred;
+  const dirtyLeavesCount = dirtyLeaves.size;
 
   if (needsUpdate) {
     editor._dirtyType = NO_DIRTY_NODES;
@@ -6034,7 +6242,7 @@ function commitPendingUpdates(editor) {
   // Reconciliation has finished. Now update selection and trigger listeners.
   // ======
 
-  const domSelection = headless ? null : getDOMSelection(); // Attempt to update the DOM selection, including focusing of the root element,
+  const domSelection = shouldSkipDOM ? null : getDOMSelection(); // Attempt to update the DOM selection, including focusing of the root element,
   // and scroll into view if needed.
 
   if (editor._editable && // domSelection will be null in headless
@@ -6043,7 +6251,25 @@ function commitPendingUpdates(editor) {
     activeEditorState = pendingEditorState;
 
     try {
-      updateDOMSelection(currentSelection, pendingSelection, editor, domSelection, tags, rootElement);
+      if (observer !== null) {
+        observer.disconnect();
+      }
+
+      if (needsUpdate || pendingSelection === null || pendingSelection.dirty) {
+        const blockCursorElement = editor._blockCursorElement;
+
+        if (blockCursorElement !== null) {
+          removeDOMBlockCursorElement(blockCursorElement, editor, rootElement);
+        }
+
+        updateDOMSelection(currentSelection, pendingSelection, editor, domSelection, tags, rootElement, dirtyLeavesCount);
+      }
+
+      updateDOMBlockCursorElement(editor, rootElement, pendingSelection);
+
+      if (observer !== null) {
+        observer.observe(rootElement, observerOptions);
+      }
     } finally {
       activeEditor = previousActiveEditor;
       activeEditorState = previousActiveEditorState;
@@ -6344,7 +6570,10 @@ function beginUpdate(editor, updateFn, options) {
     infiniteTransformCount = 0;
   }
 
-  const shouldUpdate = editor._dirtyType !== NO_DIRTY_NODES || editorStateHasDirtySelection(pendingEditorState, editor);
+  const windowObj = editor._window;
+  const windowEvent = windowObj !== null ? window.event : null;
+  const eventType = windowEvent != null ? windowEvent.type : null;
+  const shouldUpdate = editor._dirtyType !== NO_DIRTY_NODES || editorStateHasDirtySelection(pendingEditorState, editor) || editor._blockCursorElement !== null && eventType === 'blur';
 
   if (shouldUpdate) {
     if (pendingEditorState._flushSync) {
@@ -6411,44 +6640,23 @@ function removeNode(nodeToRemove, restoreSelection, preserveEmptyParent) {
     }
   }
 
-  const writableParent = parent.getWritable();
-  const parentChildren = writableParent.__children;
-  const index = parentChildren.indexOf(key);
-
-  if (index === -1) {
-    {
-      throw Error(`Node is not a child of its parent`);
-    }
-  }
-
-  internalMarkSiblingsAsDirty(nodeToRemove);
-  parentChildren.splice(index, 1);
-  const writableNodeToRemove = nodeToRemove.getWritable();
-  writableNodeToRemove.__parent = null;
-
   if ($isRangeSelection(selection) && restoreSelection && !selectionMoved) {
+    // Doing this is O(n) so lets avoid it unless we need to do it
+    const index = nodeToRemove.getIndexWithinParent();
+    removeFromParent(nodeToRemove);
     $updateElementSelectionOnCreateDeleteNode(selection, parent, index, -1);
+  } else {
+    removeFromParent(nodeToRemove);
   }
 
   if (!preserveEmptyParent && !$isRootOrShadowRoot(parent) && !parent.canBeEmpty() && parent.isEmpty()) {
     removeNode(parent, restoreSelection);
   }
 
-  if ($isRootNode(parent) && parent.isEmpty()) {
+  if (restoreSelection && $isRootNode(parent) && parent.isEmpty()) {
     parent.selectEnd();
   }
 }
-function $getNodeByKeyOrThrow(key) {
-  const node = $getNodeByKey(key);
-
-  if (node === null) {
-    {
-      throw Error(`Expected node with key ${key} to exist but it's not in the nodeMap.`);
-    }
-  }
-
-  return node;
-}
 class LexicalNode {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   // Flow doesn't support abstract classes unfortunately, so we can't _force_
@@ -6544,8 +6752,19 @@ class LexicalNode {
       return -1;
     }
 
-    const children = parent.__children;
-    return children.indexOf(this.__key);
+    let node = parent.getFirstChild();
+    let index = 0;
+
+    while (node !== null) {
+      if (this.is(node)) {
+        return index;
+      }
+
+      index++;
+      node = node.getNextSibling();
+    }
+
+    return -1;
   }
 
   getParent() {
@@ -6623,62 +6842,44 @@ class LexicalNode {
   }
 
   getPreviousSibling() {
-    const parent = this.getParent();
-
-    if (parent === null) {
-      return null;
-    }
-
-    const children = parent.__children;
-    const index = children.indexOf(this.__key);
-
-    if (index <= 0) {
-      return null;
-    }
-
-    return $getNodeByKey(children[index - 1]);
+    const self = this.getLatest();
+    const prevKey = self.__prev;
+    return prevKey === null ? null : $getNodeByKey(prevKey);
   }
 
   getPreviousSiblings() {
-    const parent = this.getParent();
+    const siblings = [];
+    const parent = this.getParentOrThrow();
+    let node = parent.getFirstChild();
 
-    if (parent === null) {
-      return [];
+    while (node !== null) {
+      if (node.is(this)) {
+        break;
+      }
+
+      siblings.push(node);
+      node = node.getNextSibling();
     }
 
-    const children = parent.__children;
-    const index = children.indexOf(this.__key);
-    return children.slice(0, index).map(childKey => $getNodeByKeyOrThrow(childKey));
+    return siblings;
   }
 
   getNextSibling() {
-    const parent = this.getParent();
-
-    if (parent === null) {
-      return null;
-    }
-
-    const children = parent.__children;
-    const childrenLength = children.length;
-    const index = children.indexOf(this.__key);
-
-    if (index >= childrenLength - 1) {
-      return null;
-    }
-
-    return $getNodeByKey(children[index + 1]);
+    const self = this.getLatest();
+    const nextKey = self.__next;
+    return nextKey === null ? null : $getNodeByKey(nextKey);
   }
 
   getNextSiblings() {
-    const parent = this.getParent();
+    const siblings = [];
+    let node = this.getNextSibling();
 
-    if (parent === null) {
-      return [];
+    while (node !== null) {
+      siblings.push(node);
+      node = node.getNextSibling();
     }
 
-    const children = parent.__children;
-    const index = children.indexOf(this.__key);
-    return children.slice(index + 1).map(childKey => $getNodeByKeyOrThrow(childKey));
+    return siblings;
   }
 
   getCommonAncestor(node) {
@@ -6739,7 +6940,7 @@ class LexicalNode {
       const parent = node.getParentOrThrow();
 
       if (parent === commonAncestor) {
-        indexA = parent.__children.indexOf(node.__key);
+        indexA = node.getIndexWithinParent();
         break;
       }
 
@@ -6752,7 +6953,7 @@ class LexicalNode {
       const parent = node.getParentOrThrow();
 
       if (parent === commonAncestor) {
-        indexB = parent.__children.indexOf(node.__key);
+        indexB = node.getIndexWithinParent();
         break;
       }
 
@@ -6898,9 +7099,13 @@ class LexicalNode {
 
     const mutableNode = constructor.clone(latestNode);
     mutableNode.__parent = parent;
+    mutableNode.__next = latestNode.__next;
+    mutableNode.__prev = latestNode.__prev;
 
     if ($isElementNode(latestNode) && $isElementNode(mutableNode)) {
-      mutableNode.__children = Array.from(latestNode.__children);
+      mutableNode.__first = latestNode.__first;
+      mutableNode.__last = latestNode.__last;
+      mutableNode.__size = latestNode.__size;
       mutableNode.__indent = latestNode.__indent;
       mutableNode.__format = latestNode.__format;
       mutableNode.__dir = latestNode.__dir;
@@ -6975,31 +7180,45 @@ class LexicalNode {
     removeNode(this, true, preserveEmptyParent);
   }
 
-  replace(replaceWith) {
+  replace(replaceWith, restoreSelection = true) {
     errorOnReadOnly();
     errorOnInsertTextNodeOnRoot(this, replaceWith);
+    const self = this.getLatest();
     const toReplaceKey = this.__key;
+    const key = replaceWith.__key;
     const writableReplaceWith = replaceWith.getWritable();
+    const writableParent = this.getParentOrThrow().getWritable();
+    const size = writableParent.__size;
     removeFromParent(writableReplaceWith);
-    const newParent = this.getParentOrThrow();
-    const writableParent = newParent.getWritable();
-    const children = writableParent.__children;
-    const index = children.indexOf(this.__key);
-    const newKey = writableReplaceWith.__key;
+    const prevSibling = self.getPreviousSibling();
+    const nextSibling = self.getNextSibling();
+    const prevKey = self.__prev;
+    const nextKey = self.__next;
+    const parentKey = self.__parent;
+    removeNode(self, false);
 
-    if (index === -1) {
-      {
-        throw Error(`Node is not a child of its parent`);
-      }
+    if (prevSibling === null) {
+      writableParent.__first = key;
+    } else {
+      const writablePrevSibling = prevSibling.getWritable();
+      writablePrevSibling.__next = key;
     }
 
-    children.splice(index, 0, newKey);
-    writableReplaceWith.__parent = newParent.__key;
-    removeNode(this, false);
-    internalMarkSiblingsAsDirty(writableReplaceWith);
+    writableReplaceWith.__prev = prevKey;
+
+    if (nextSibling === null) {
+      writableParent.__last = key;
+    } else {
+      const writableNextSibling = nextSibling.getWritable();
+      writableNextSibling.__prev = key;
+    }
+
+    writableReplaceWith.__next = nextKey;
+    writableReplaceWith.__parent = parentKey;
+    writableParent.__size = size;
     const selection = $getSelection();
 
-    if ($isRangeSelection(selection)) {
+    if ($isRangeSelection(selection) && restoreSelection) {
       const anchor = selection.anchor;
       const focus = selection.focus;
 
@@ -7013,24 +7232,25 @@ class LexicalNode {
     }
 
     if ($getCompositionKey() === toReplaceKey) {
-      $setCompositionKey(newKey);
+      $setCompositionKey(key);
     }
 
     return writableReplaceWith;
   }
 
-  insertAfter(nodeToInsert) {
+  insertAfter(nodeToInsert, restoreSelection = true) {
     errorOnReadOnly();
     errorOnInsertTextNodeOnRoot(this, nodeToInsert);
     const writableSelf = this.getWritable();
     const writableNodeToInsert = nodeToInsert.getWritable();
     const oldParent = writableNodeToInsert.getParent();
     const selection = $getSelection();
-    const oldIndex = nodeToInsert.getIndexWithinParent();
     let elementAnchorSelectionOnNode = false;
     let elementFocusSelectionOnNode = false;
 
     if (oldParent !== null) {
+      // TODO: this is O(n), can we improve?
+      const oldIndex = nodeToInsert.getIndexWithinParent();
       removeFromParent(writableNodeToInsert);
 
       if ($isRangeSelection(selection)) {
@@ -7042,22 +7262,26 @@ class LexicalNode {
       }
     }
 
+    const nextSibling = this.getNextSibling();
     const writableParent = this.getParentOrThrow().getWritable();
     const insertKey = writableNodeToInsert.__key;
-    writableNodeToInsert.__parent = writableSelf.__parent;
-    const children = writableParent.__children;
-    const index = children.indexOf(writableSelf.__key);
+    const nextKey = writableSelf.__next;
 
-    if (index === -1) {
-      {
-        throw Error(`Node is not a child of its parent`);
-      }
+    if (nextSibling === null) {
+      writableParent.__last = insertKey;
+    } else {
+      const writableNextSibling = nextSibling.getWritable();
+      writableNextSibling.__prev = insertKey;
     }
 
-    children.splice(index + 1, 0, insertKey);
-    internalMarkSiblingsAsDirty(writableNodeToInsert);
+    writableParent.__size++;
+    writableSelf.__next = insertKey;
+    writableNodeToInsert.__next = nextKey;
+    writableNodeToInsert.__prev = writableSelf.__key;
+    writableNodeToInsert.__parent = writableSelf.__parent;
 
-    if ($isRangeSelection(selection)) {
+    if (restoreSelection && $isRangeSelection(selection)) {
+      const index = this.getIndexWithinParent();
       $updateElementSelectionOnCreateDeleteNode(selection, writableParent, index + 1);
       const writableParentKey = writableParent.__key;
 
@@ -7073,30 +7297,36 @@ class LexicalNode {
     return nodeToInsert;
   }
 
-  insertBefore(nodeToInsert) {
+  insertBefore(nodeToInsert, restoreSelection = true) {
     errorOnReadOnly();
     errorOnInsertTextNodeOnRoot(this, nodeToInsert);
     const writableSelf = this.getWritable();
     const writableNodeToInsert = nodeToInsert.getWritable();
+    const insertKey = writableNodeToInsert.__key;
     removeFromParent(writableNodeToInsert);
+    const prevSibling = this.getPreviousSibling();
     const writableParent = this.getParentOrThrow().getWritable();
-    const insertKey = writableNodeToInsert.__key;
-    writableNodeToInsert.__parent = writableSelf.__parent;
-    const children = writableParent.__children;
-    const index = children.indexOf(writableSelf.__key);
+    const prevKey = writableSelf.__prev; // TODO: this is O(n), can we improve?
 
-    if (index === -1) {
-      {
-        throw Error(`Node is not a child of its parent`);
-      }
+    const index = this.getIndexWithinParent();
+
+    if (prevSibling === null) {
+      writableParent.__first = insertKey;
+    } else {
+      const writablePrevSibling = prevSibling.getWritable();
+      writablePrevSibling.__next = insertKey;
     }
 
-    children.splice(index, 0, insertKey);
-    internalMarkSiblingsAsDirty(writableNodeToInsert);
+    writableParent.__size++;
+    writableSelf.__prev = insertKey;
+    writableNodeToInsert.__prev = prevKey;
+    writableNodeToInsert.__next = writableSelf.__key;
+    writableNodeToInsert.__parent = writableSelf.__parent;
     const selection = $getSelection();
 
-    if ($isRangeSelection(selection)) {
-      $updateElementSelectionOnCreateDeleteNode(selection, writableParent, index);
+    if (restoreSelection && $isRangeSelection(selection)) {
+      const parent = this.getParentOrThrow();
+      $updateElementSelectionOnCreateDeleteNode(selection, parent, index);
     }
 
     return nodeToInsert;
@@ -7223,13 +7453,9 @@ class ElementNode extends LexicalNode {
 
   /** @internal */
 
-  /** @internal */
-
   /** @internal */
   constructor(key) {
-    super(key); // TODO: remove children and switch to using first/last as part of linked list work
-
-    this.__children = [];
+    super(key);
     this.__first = null;
     this.__last = null;
     this.__size = 0;
@@ -7254,28 +7480,32 @@ class ElementNode extends LexicalNode {
   }
 
   getChildren() {
-    const self = this.getLatest();
-    const children = self.__children;
-    const childrenNodes = [];
+    const children = [];
+    let child = this.getFirstChild();
 
-    for (let i = 0; i < children.length; i++) {
-      const childNode = $getNodeByKey(children[i]);
-
-      if (childNode !== null) {
-        childrenNodes.push(childNode);
-      }
+    while (child !== null) {
+      children.push(child);
+      child = child.getNextSibling();
     }
 
-    return childrenNodes;
+    return children;
   }
 
   getChildrenKeys() {
-    return this.getLatest().__children;
+    const children = [];
+    let child = this.getFirstChild();
+
+    while (child !== null) {
+      children.push(child.__key);
+      child = child.getNextSibling();
+    }
+
+    return children;
   }
 
   getChildrenSize() {
     const self = this.getLatest();
-    return self.__children.length;
+    return self.__size;
   }
 
   isEmpty() {
@@ -7290,24 +7520,25 @@ class ElementNode extends LexicalNode {
 
   isLastChild() {
     const self = this.getLatest();
-    const parent = self.getParentOrThrow();
-    return parent.getLastChild() === self;
+    const parentLastChild = this.getParentOrThrow().getLastChild();
+    return parentLastChild !== null && parentLastChild.is(self);
   }
 
   getAllTextNodes() {
     const textNodes = [];
-    const self = this.getLatest();
-    const children = self.__children;
+    let child = this.getFirstChild();
 
-    for (let i = 0; i < children.length; i++) {
-      const childNode = $getNodeByKey(children[i]);
+    while (child !== null) {
+      if ($isTextNode(child)) {
+        textNodes.push(child);
+      }
 
-      if ($isTextNode(childNode)) {
-        textNodes.push(childNode);
-      } else if ($isElementNode(childNode)) {
-        const subChildrenNodes = childNode.getAllTextNodes();
+      if ($isElementNode(child)) {
+        const subChildrenNodes = child.getAllTextNodes();
         textNodes.push(...subChildrenNodes);
       }
+
+      child = child.getNextSibling();
     }
 
     return textNodes;
@@ -7367,14 +7598,8 @@ class ElementNode extends LexicalNode {
 
   getFirstChild() {
     const self = this.getLatest();
-    const children = self.__children;
-    const childrenLength = children.length;
-
-    if (childrenLength === 0) {
-      return null;
-    }
-
-    return $getNodeByKey(children[0]);
+    const firstKey = self.__first;
+    return firstKey === null ? null : $getNodeByKey(firstKey);
   }
 
   getFirstChildOrThrow() {
@@ -7391,14 +7616,8 @@ class ElementNode extends LexicalNode {
 
   getLastChild() {
     const self = this.getLatest();
-    const children = self.__children;
-    const childrenLength = children.length;
-
-    if (childrenLength === 0) {
-      return null;
-    }
-
-    return $getNodeByKey(children[childrenLength - 1]);
+    const lastKey = self.__last;
+    return lastKey === null ? null : $getNodeByKey(lastKey);
   }
 
   getLastChildOrThrow() {
@@ -7414,15 +7633,39 @@ class ElementNode extends LexicalNode {
   }
 
   getChildAtIndex(index) {
-    const self = this.getLatest();
-    const children = self.__children;
-    const key = children[index];
+    const size = this.getChildrenSize();
+    let node;
+    let i;
+
+    if (index < size / 2) {
+      node = this.getFirstChild();
+      i = 0;
+
+      while (node !== null && i <= index) {
+        if (i === index) {
+          return node;
+        }
+
+        node = node.getNextSibling();
+        i++;
+      }
 
-    if (key === undefined) {
       return null;
     }
 
-    return $getNodeByKey(key);
+    node = this.getLastChild();
+    i = size - 1;
+
+    while (node !== null && i >= index) {
+      if (i === index) {
+        return node;
+      }
+
+      node = node.getPreviousSibling();
+      i--;
+    }
+
+    return null;
   }
 
   getTextContent() {
@@ -7464,6 +7707,22 @@ class ElementNode extends LexicalNode {
     let focusOffset = _focusOffset;
     const childrenCount = this.getChildrenSize();
 
+    if (!this.canBeEmpty()) {
+      if (_anchorOffset === 0 && _focusOffset === 0) {
+        const firstChild = this.getFirstChild();
+
+        if ($isTextNode(firstChild) || $isElementNode(firstChild)) {
+          return firstChild.select(0, 0);
+        }
+      } else if ((_anchorOffset === undefined || _anchorOffset === childrenCount) && (_focusOffset === undefined || _focusOffset === childrenCount)) {
+        const lastChild = this.getLastChild();
+
+        if ($isTextNode(lastChild) || $isElementNode(lastChild)) {
+          return lastChild.select();
+        }
+      }
+    }
+
     if (anchorOffset === undefined) {
       anchorOffset = childrenCount;
     }
@@ -7545,55 +7804,108 @@ class ElementNode extends LexicalNode {
   }
 
   splice(start, deleteCount, nodesToInsert) {
+    const nodesToInsertLength = nodesToInsert.length;
+    const oldSize = this.getChildrenSize();
     const writableSelf = this.getWritable();
     const writableSelfKey = writableSelf.__key;
-    const writableSelfChildren = writableSelf.__children;
-    const nodesToInsertLength = nodesToInsert.length;
-    const nodesToInsertKeys = []; // Remove nodes to insert from their previous parent
+    const nodesToInsertKeys = [];
+    const nodesToRemoveKeys = [];
+    const nodeAfterRange = this.getChildAtIndex(start + deleteCount);
+    let nodeBeforeRange = null;
+    let newSize = oldSize - deleteCount + nodesToInsertLength;
+
+    if (start !== 0) {
+      if (start === oldSize) {
+        nodeBeforeRange = this.getLastChild();
+      } else {
+        const node = this.getChildAtIndex(start);
+
+        if (node !== null) {
+          nodeBeforeRange = node.getPreviousSibling();
+        }
+      }
+    }
+
+    if (deleteCount > 0) {
+      let nodeToDelete = nodeBeforeRange === null ? this.getFirstChild() : nodeBeforeRange.getNextSibling();
+
+      for (let i = 0; i < deleteCount; i++) {
+        if (nodeToDelete === null) {
+          {
+            throw Error(`splice: sibling not found`);
+          }
+        }
+
+        const nextSibling = nodeToDelete.getNextSibling();
+        const nodeKeyToDelete = nodeToDelete.__key;
+        const writableNodeToDelete = nodeToDelete.getWritable();
+        removeFromParent(writableNodeToDelete);
+        nodesToRemoveKeys.push(nodeKeyToDelete);
+        nodeToDelete = nextSibling;
+      }
+    }
+
+    let prevNode = nodeBeforeRange;
 
     for (let i = 0; i < nodesToInsertLength; i++) {
       const nodeToInsert = nodesToInsert[i];
+
+      if (prevNode !== null && nodeToInsert.is(prevNode)) {
+        nodeBeforeRange = prevNode = prevNode.getPreviousSibling();
+      }
+
       const writableNodeToInsert = nodeToInsert.getWritable();
 
+      if (writableNodeToInsert.__parent === writableSelfKey) {
+        newSize--;
+      }
+
+      removeFromParent(writableNodeToInsert);
+      const nodeKeyToInsert = nodeToInsert.__key;
+
+      if (prevNode === null) {
+        writableSelf.__first = nodeKeyToInsert;
+        writableNodeToInsert.__prev = null;
+      } else {
+        const writablePrevNode = prevNode.getWritable();
+        writablePrevNode.__next = nodeKeyToInsert;
+        writableNodeToInsert.__prev = writablePrevNode.__key;
+      }
+
       if (nodeToInsert.__key === writableSelfKey) {
         {
           throw Error(`append: attempting to append self`);
         }
-      }
+      } // Set child parent to self
 
-      removeFromParent(writableNodeToInsert); // Set child parent to self
 
       writableNodeToInsert.__parent = writableSelfKey;
-      const newKey = writableNodeToInsert.__key;
-      nodesToInsertKeys.push(newKey);
-    } // Mark range edges siblings as dirty
-
-
-    const nodeBeforeRange = this.getChildAtIndex(start - 1);
-
-    if (nodeBeforeRange) {
-      internalMarkNodeAsDirty(nodeBeforeRange);
+      nodesToInsertKeys.push(nodeKeyToInsert);
+      prevNode = nodeToInsert;
     }
 
-    const nodeAfterRange = this.getChildAtIndex(start + deleteCount);
-
-    if (nodeAfterRange) {
-      internalMarkNodeAsDirty(nodeAfterRange);
-    } // Remove defined range of children
-
+    if (start + deleteCount === oldSize) {
+      if (prevNode !== null) {
+        const writablePrevNode = prevNode.getWritable();
+        writablePrevNode.__next = null;
+        writableSelf.__last = prevNode.__key;
+      }
+    } else if (nodeAfterRange !== null) {
+      const writableNodeAfterRange = nodeAfterRange.getWritable();
 
-    let nodesToRemoveKeys; // Using faster push when only appending nodes
+      if (prevNode !== null) {
+        const writablePrevNode = prevNode.getWritable();
+        writableNodeAfterRange.__prev = prevNode.__key;
+        writablePrevNode.__next = nodeAfterRange.__key;
+      } else {
+        writableNodeAfterRange.__prev = null;
+      }
+    }
 
-    if (start === writableSelfChildren.length) {
-      writableSelfChildren.push(...nodesToInsertKeys);
-      nodesToRemoveKeys = [];
-    } else {
-      nodesToRemoveKeys = writableSelfChildren.splice(start, deleteCount, ...nodesToInsertKeys);
-    } // In case of deletion we need to adjust selection, unlink removed nodes
+    writableSelf.__size = newSize; // In case of deletion we need to adjust selection, unlink removed nodes
     // and clean up node itself if it becomes empty. None of these needed
     // for insertion-only cases
 
-
     if (nodesToRemoveKeys.length) {
       // Adjusting selection, in case node that was anchor/focus will be deleted
       const selection = $getSelection();
@@ -7601,50 +7913,21 @@ class ElementNode extends LexicalNode {
       if ($isRangeSelection(selection)) {
         const nodesToRemoveKeySet = new Set(nodesToRemoveKeys);
         const nodesToInsertKeySet = new Set(nodesToInsertKeys);
-
-        const isPointRemoved = point => {
-          let node = point.getNode();
-
-          while (node) {
-            const nodeKey = node.__key;
-
-            if (nodesToRemoveKeySet.has(nodeKey) && !nodesToInsertKeySet.has(nodeKey)) {
-              return true;
-            }
-
-            node = node.getParent();
-          }
-
-          return false;
-        };
-
         const {
           anchor,
           focus
         } = selection;
 
-        if (isPointRemoved(anchor)) {
+        if (isPointRemoved(anchor, nodesToRemoveKeySet, nodesToInsertKeySet)) {
           moveSelectionPointToSibling(anchor, anchor.getNode(), this, nodeBeforeRange, nodeAfterRange);
         }
 
-        if (isPointRemoved(focus)) {
+        if (isPointRemoved(focus, nodesToRemoveKeySet, nodesToInsertKeySet)) {
           moveSelectionPointToSibling(focus, focus.getNode(), this, nodeBeforeRange, nodeAfterRange);
-        } // Unlink removed nodes from current parent
-
-
-        const nodesToRemoveKeysLength = nodesToRemoveKeys.length;
-
-        for (let i = 0; i < nodesToRemoveKeysLength; i++) {
-          const nodeToRemove = $getNodeByKey(nodesToRemoveKeys[i]);
-
-          if (nodeToRemove != null) {
-            const writableNodeToRemove = nodeToRemove.getWritable();
-            writableNodeToRemove.__parent = null;
-          }
         } // Cleanup if node can't be empty
 
 
-        if (writableSelfChildren.length === 0 && !this.canBeEmpty() && !$isRootOrShadowRoot(this)) {
+        if (newSize === 0 && !this.canBeEmpty() && !$isRootOrShadowRoot(this)) {
           this.remove();
         }
       }
@@ -7666,7 +7949,7 @@ class ElementNode extends LexicalNode {
   } // These are intended to be extends for specific element heuristics.
 
 
-  insertNewAfter(selection) {
+  insertNewAfter(selection, restoreSelection) {
     return null;
   }
 
@@ -7741,6 +8024,22 @@ function $isElementNode(node) {
   return node instanceof ElementNode;
 }
 
+function isPointRemoved(point, nodesToRemoveKeySet, nodesToInsertKeySet) {
+  let node = point.getNode();
+
+  while (node) {
+    const nodeKey = node.__key;
+
+    if (nodesToRemoveKeySet.has(nodeKey) && !nodesToInsertKeySet.has(nodeKey)) {
+      return true;
+    }
+
+    node = node.getParent();
+  }
+
+  return false;
+}
+
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -8183,6 +8482,13 @@ function createTextInnerDOM(innerDOM, node, innerTag, format, text, config) {
 
 
 class TextNode extends LexicalNode {
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
   static getType() {
     return 'text';
   }
@@ -8383,6 +8689,14 @@ class TextNode extends LexicalNode {
         conversion: convertTextFormatElement,
         priority: 0
       }),
+      sub: node => ({
+        conversion: convertTextFormatElement,
+        priority: 0
+      }),
+      sup: node => ({
+        conversion: convertTextFormatElement,
+        priority: 0
+      }),
       u: node => ({
         conversion: convertTextFormatElement,
         priority: 0
@@ -8581,7 +8895,6 @@ class TextNode extends LexicalNode {
 
     const firstPart = parts[0];
     const parent = self.getParentOrThrow();
-    const parentKey = parent.__key;
     let writableNode;
     const format = self.getFormat();
     const style = self.getStyle();
@@ -8591,7 +8904,6 @@ class TextNode extends LexicalNode {
     if (self.isSegmented()) {
       // Create a new TextNode
       writableNode = $createTextNode(firstPart);
-      writableNode.__parent = parentKey;
       writableNode.__format = format;
       writableNode.__style = style;
       writableNode.__detail = detail;
@@ -8640,22 +8952,19 @@ class TextNode extends LexicalNode {
       }
 
       textSize = nextTextSize;
-      sibling.__parent = parentKey;
       splitNodes.push(sibling);
     } // Insert the nodes into the parent's children
 
 
     internalMarkSiblingsAsDirty(this);
     const writableParent = parent.getWritable();
-    const writableParentChildren = writableParent.__children;
-    const insertionIndex = writableParentChildren.indexOf(key);
-    const splitNodesKeys = splitNodes.map(splitNode => splitNode.__key);
+    const insertionIndex = this.getIndexWithinParent();
 
     if (hasReplacedSelf) {
-      writableParentChildren.splice(insertionIndex, 0, ...splitNodesKeys);
+      writableParent.splice(insertionIndex, 0, splitNodes);
       this.remove();
     } else {
-      writableParentChildren.splice(insertionIndex, 1, ...splitNodesKeys);
+      writableParent.splice(insertionIndex, 1, splitNodes);
     }
 
     if ($isRangeSelection(selection)) {
@@ -8804,6 +9113,8 @@ const nodeNameToTextFormat = {
   em: 'italic',
   i: 'italic',
   strong: 'bold',
+  sub: 'subscript',
+  sup: 'superscript',
   u: 'underline'
 };
 
@@ -8927,11 +9238,11 @@ class ParagraphNode extends ElementNode {
   } // Mutation
 
 
-  insertNewAfter() {
+  insertNewAfter(_, restoreSelection) {
     const newElement = $createParagraphNode();
     const direction = this.getDirection();
     newElement.setDirection(direction);
-    this.insertAfter(newElement);
+    this.insertAfter(newElement, restoreSelection);
     return newElement;
   }
 
@@ -9005,6 +9316,7 @@ function resetEditor(editor, prevRootElement, nextRootElement, pendingEditorStat
   editor._normalizedNodes = new Set();
   editor._updateTags = new Set();
   editor._updates = [];
+  editor._blockCursorElement = null;
   const observer = editor._observer;
 
   if (observer !== null) {
@@ -9191,8 +9503,9 @@ class LexicalEditor {
     // Doing so, causes e2e tests around the lock to fail.
 
     this._editable = true;
-    this._headless = false;
+    this._headless = parentEditor !== null && parentEditor._headless;
     this._window = null;
+    this._blockCursorElement = null;
   }
 
   isComposing() {
@@ -9515,7 +9828,7 @@ class LexicalEditor {
  * LICENSE file in the root directory of this source tree.
  *
  */
-const VERSION = '0.6.4';
+const VERSION = '0.7.0';
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -9576,7 +9889,7 @@ exports.$createNodeSelection = $createNodeSelection;
 exports.$createParagraphNode = $createParagraphNode;
 exports.$createRangeSelection = $createRangeSelection;
 exports.$createTextNode = $createTextNode;
-exports.$getDecoratorNode = $getDecoratorNode;
+exports.$getAdjacentNode = $getAdjacentNode;
 exports.$getNearestNodeFromDOMNode = $getNearestNodeFromDOMNode;
 exports.$getNearestRootOrShadowRoot = $getNearestRootOrShadowRoot;
 exports.$getNodeByKey = $getNodeByKey;