lexical 0.6.5 → 0.7.0

package/Lexical.dev.js

@@ -272,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 = '';
 
@@ -304,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;
 
@@ -326,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++;
               }
@@ -350,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++) {
@@ -590,22 +591,60 @@ 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;
     }
 
-    internalMarkSiblingsAsDirty(writableNode);
-    children.splice(index, 1);
+    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;
+    }
+
+    writableParent.__size--;
     writableNode.__parent = null;
   }
 } // Never use this function directly! It will break
@@ -1207,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') {
@@ -1437,16 +1476,95 @@ function errorOnInsertTextNodeOnRoot(node, insertNode) {
     }
   }
 }
-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.`);
+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 node;
+  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);
+  }
 }
 
 /**
@@ -1475,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)) {
@@ -1495,6 +1611,8 @@ function $garbageCollectDetachedDeepChildNodes(node, parentKey, prevNodeMap, nod
 
       nodeMap.delete(childKey);
     }
+
+    child = child.isAttached() ? child.getNextSibling() : null;
   }
 }
 
@@ -1661,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.
 
@@ -1671,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);
   }
 
@@ -1742,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);
     }
 
@@ -1762,7 +1882,7 @@ function createNode(key, parentDOM, insertDOM) {
     }
 
     if (!node.isInline()) {
-      reconcileElementTerminatingLineBreak(null, children, dom);
+      reconcileElementTerminatingLineBreak(null, node, dom);
     }
 
     if ($textContentRequiresDoubleLinebreakAtEnd(node)) {
@@ -1837,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) {
@@ -1929,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
 
@@ -2064,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);
       }
     }
 
@@ -2132,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;
@@ -3099,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);
@@ -3913,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.
 
@@ -3967,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;
           }
 
@@ -4010,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();
@@ -4055,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.
 
 
@@ -4392,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();
 
@@ -4419,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.
@@ -4578,7 +4726,7 @@ class RangeSelection {
         paragraph.select();
 
         if (child !== null) {
-          child.insertBefore(paragraph);
+          child.insertBefore(paragraph, false);
         } else {
           currentElement.append(paragraph);
         }
@@ -4593,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();
@@ -4606,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
@@ -4738,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
@@ -4793,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
@@ -4875,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
@@ -5070,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
@@ -5091,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)) {
@@ -5114,7 +5281,7 @@ function internalResolveSelectionPoint(dom, offset, lastPoint) {
             resolvedOffset = 0;
           } else {
             child = descendant;
-            resolvedElement = child.getParentOrThrow();
+            resolvedElement = $isElementNode(child) ? child : child.getParentOrThrow();
           }
         }
 
@@ -5122,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 {
@@ -5231,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;
@@ -5689,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;
 }
@@ -5969,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.
@@ -5991,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.
@@ -6025,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;
@@ -6074,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
@@ -6083,7 +6251,25 @@ function commitPendingUpdates(editor) {
     activeEditorState = pendingEditorState;
 
     try {
-      updateDOMSelection(currentSelection, pendingSelection, editor, domSelection, tags, rootElement, dirtyLeavesCount);
+      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;
@@ -6384,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) {
@@ -6451,29 +6640,20 @@ 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`);
-    }
-  }
-
-  const writableNodeToRemove = nodeToRemove.getWritable();
-  internalMarkSiblingsAsDirty(nodeToRemove);
-  removeFromParent(writableNodeToRemove);
-
   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();
   }
 }
@@ -6572,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() {
@@ -6651,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) {
@@ -6767,7 +6940,7 @@ class LexicalNode {
       const parent = node.getParentOrThrow();
 
       if (parent === commonAncestor) {
-        indexA = parent.__children.indexOf(node.__key);
+        indexA = node.getIndexWithinParent();
         break;
       }
 
@@ -6780,7 +6953,7 @@ class LexicalNode {
       const parent = node.getParentOrThrow();
 
       if (parent === commonAncestor) {
-        indexB = parent.__children.indexOf(node.__key);
+        indexB = node.getIndexWithinParent();
         break;
       }
 
@@ -6930,7 +7103,6 @@ class LexicalNode {
     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;
@@ -7008,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;
 
@@ -7046,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)) {
@@ -7075,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;
 
@@ -7106,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;
@@ -7256,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;
@@ -7287,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() {
@@ -7323,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;
@@ -7400,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() {
@@ -7424,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() {
@@ -7447,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() {
@@ -7497,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;
     }
@@ -7578,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();
@@ -7645,22 +7924,10 @@ class ElementNode extends LexicalNode {
 
         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();
         }
       }
@@ -7682,7 +7949,7 @@ class ElementNode extends LexicalNode {
   } // These are intended to be extends for specific element heuristics.
 
 
-  insertNewAfter(selection) {
+  insertNewAfter(selection, restoreSelection) {
     return null;
   }
 
@@ -8215,6 +8482,13 @@ function createTextInnerDOM(innerDOM, node, innerTag, format, text, config) {
 
 
 class TextNode extends LexicalNode {
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
   static getType() {
     return 'text';
   }
@@ -8621,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();
@@ -8631,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;
@@ -8680,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)) {
@@ -8969,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;
   }
 
@@ -9047,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) {
@@ -9235,6 +9505,7 @@ class LexicalEditor {
     this._editable = true;
     this._headless = parentEditor !== null && parentEditor._headless;
     this._window = null;
+    this._blockCursorElement = null;
   }
 
   isComposing() {
@@ -9557,7 +9828,7 @@ class LexicalEditor {
  * LICENSE file in the root directory of this source tree.
  *
  */
-const VERSION = '0.6.5';
+const VERSION = '0.7.0';
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -9618,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;