lexical 0.4.0 → 0.5.0

package/Lexical.dev.js

@@ -104,8 +104,8 @@ const FULL_RECONCILE = 2; // Text node modes
 
 const IS_NORMAL = 0;
 const IS_TOKEN = 1;
-const IS_SEGMENTED = 2;
-const IS_INERT = 3; // Text node formatting
+const IS_SEGMENTED = 2; // IS_INERT = 3
+// Text node formatting
 
 const IS_BOLD = 1;
 const IS_ITALIC = 1 << 1;
@@ -165,13 +165,11 @@ const ELEMENT_FORMAT_TO_TYPE = {
   [IS_ALIGN_RIGHT]: 'right'
 };
 const TEXT_MODE_TO_TYPE = {
-  inert: IS_INERT,
   normal: IS_NORMAL,
   segmented: IS_SEGMENTED,
   token: IS_TOKEN
 };
 const TEXT_TYPE_TO_MODE = {
-  [IS_INERT]: 'inert',
   [IS_NORMAL]: 'normal',
   [IS_SEGMENTED]: 'segmented',
   [IS_TOKEN]: 'token'
@@ -490,11 +488,8 @@ function getTextDirection(text) {
 
   return null;
 }
-function $isTokenOrInertOrSegmented(node) {
-  return $isTokenOrInert(node) || node.isSegmented();
-}
-function $isTokenOrInert(node) {
-  return node.isToken() || node.isInert();
+function $isTokenOrSegmented(node) {
+  return node.isToken() || node.isSegmented();
 }
 
 function isDOMNodeLexicalTextNode(node) {
@@ -660,6 +655,10 @@ function $setCompositionKey(compositionKey) {
   }
 }
 function $getCompositionKey() {
+  if (isCurrentlyReadOnlyMode()) {
+    return null;
+  }
+
   const editor = getActiveEditor();
   return editor._compositionKey;
 }
@@ -886,7 +885,7 @@ function $updateTextNodeFromDOMContent(textNode, textContent, anchorOffset, focu
       const parent = node.getParent();
       const prevSelection = $getPreviousSelection();
 
-      if ($isTokenOrInert(node) || $getCompositionKey() !== null && !isComposing || // Check if character was added at the start, and we need
+      if (node.isToken() || $getCompositionKey() !== null && !isComposing || // Check if character was added at the start, and we need
       // to clear this input from occurring as that action wasn't
       // permitted.
       parent !== null && $isRangeSelection(prevSelection) && !parent.canInsertTextBefore() && prevSelection.anchor.offset === 0) {
@@ -918,7 +917,10 @@ function $updateTextNodeFromDOMContent(textNode, textContent, anchorOffset, focu
 function $previousSiblingDoesNotAcceptText(node) {
   const previousSibling = node.getPreviousSibling();
   return ($isTextNode(previousSibling) || $isElementNode(previousSibling) && previousSibling.isInline()) && !previousSibling.canInsertTextAfter();
-}
+} // This function is connected to $shouldPreventDefaultAndInsertText and determines whether the
+// TextNode boundaries are writable or we should use the previous/next sibling instead. For example,
+// in the case of a LinkNode, boundaries are not writable.
+
 
 function $shouldInsertTextAfterOrBeforeTextNode(selection, node) {
   if (node.isSegmented()) {
@@ -932,9 +934,14 @@ function $shouldInsertTextAfterOrBeforeTextNode(selection, node) {
   const offset = selection.anchor.offset;
   const parent = node.getParentOrThrow();
   const isToken = node.isToken();
-  const shouldInsertTextBefore = offset === 0 && (!node.canInsertTextBefore() || !parent.canInsertTextBefore() || isToken || $previousSiblingDoesNotAcceptText(node));
-  const shouldInsertTextAfter = node.getTextContentSize() === offset && (!node.canInsertTextBefore() || !parent.canInsertTextBefore() || isToken);
-  return shouldInsertTextBefore || shouldInsertTextAfter;
+
+  if (offset === 0) {
+    return !node.canInsertTextBefore() || !parent.canInsertTextBefore() || isToken || $previousSiblingDoesNotAcceptText(node);
+  } else if (offset === node.getTextContentSize()) {
+    return !node.canInsertTextAfter() || !parent.canInsertTextAfter() || isToken;
+  } else {
+    return false;
+  }
 } // This function is used to determine if Lexical should attempt to override
 // the default browser behavior for insertion of text and use its own internal
 // heuristics. This is an extremely important function, and makes much of Lexical
@@ -955,7 +962,7 @@ function $shouldPreventDefaultAndInsertText(selection, text) {
   return anchorKey !== focus.key || // If we're working with a non-text node.
   !$isTextNode(anchorNode) || // If we are replacing a range with a single character or grapheme, and not composing.
   (textLength < 2 || doesContainGrapheme(text)) && anchor.offset !== focus.offset && !anchorNode.isComposing() || // Any non standard text node.
-  $isTokenOrInertOrSegmented(anchorNode) || // If the text length is more than a single character and we're either
+  $isTokenOrSegmented(anchorNode) || // If the text length is more than a single character and we're either
   // dealing with this in "beforeinput" or where the node has already recently
   // been changed (thus is dirty).
   anchorNode.isDirty() && textLength > 1 || // If the DOM selection element is not the same as the backing node
@@ -1274,6 +1281,12 @@ function scrollIntoViewIfNeeded(editor, anchor, rootElement, tags) {
     tags.add('scroll-into-view');
   }
 }
+function $addUpdateTag(tag) {
+  errorOnReadOnly();
+  const editor = getActiveEditor();
+
+  editor._updateTags.add(tag);
+}
 function $maybeMoveChildrenSelectionToParent(parentNode, offset = 0) {
   if (offset !== 0) {
     {
@@ -1304,7 +1317,6 @@ function $maybeMoveChildrenSelectionToParent(parentNode, offset = 0) {
 
   return selection;
 }
-
 function $hasAncestor(child, targetNode) {
   let parent = child.getParent();
 
@@ -1318,7 +1330,6 @@ function $hasAncestor(child, targetNode) {
 
   return false;
 }
-
 function getDefaultView(domElem) {
   const ownerDoc = domElem.ownerDocument;
   return ownerDoc && ownerDoc.defaultView || null;
@@ -1334,6 +1345,12 @@ function getWindow(editor) {
 
   return windowObj;
 }
+function $isInlineElementOrDecoratorNode(node) {
+  return $isElementNode(node) && node.isInline() || $isDecoratorNode(node) && node.isInline();
+}
+function $isRootOrShadowRoot(node) {
+  return $isRootNode(node) || $isElementNode(node) && node.isShadowRoot();
+}
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -1486,6 +1503,37 @@ function $normalizeTextNode(textNode) {
     }
   }
 }
+function $normalizeSelection(selection) {
+  $normalizePoint(selection.anchor);
+  $normalizePoint(selection.focus);
+  return selection;
+}
+
+function $normalizePoint(point) {
+  while (point.type === 'element') {
+    const node = point.getNode();
+    const offset = point.offset;
+    let nextNode;
+    let nextOffsetAtEnd;
+
+    if (offset === node.getChildrenSize()) {
+      nextNode = node.getChildAtIndex(offset - 1);
+      nextOffsetAtEnd = true;
+    } else {
+      nextNode = node.getChildAtIndex(offset);
+      nextOffsetAtEnd = false;
+    }
+
+    if ($isTextNode(nextNode)) {
+      point.set(nextNode.__key, nextOffsetAtEnd ? nextNode.getTextContentSize() : 0, 'text');
+      break;
+    } else if (!$isElementNode(nextNode)) {
+      break;
+    }
+
+    point.set(nextNode.__key, nextOffsetAtEnd ? nextNode.getChildrenSize() : 0, 'element');
+  }
+}
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -1634,15 +1682,6 @@ function createNode(key, parentDOM, insertDOM) {
       if (!node.isDirectionless()) {
         subTreeDirectionedTextContent += text;
       }
-
-      if (node.isInert()) {
-        const domStyle = dom.style;
-        domStyle.pointerEvents = 'none';
-        domStyle.userSelect = 'none';
-        dom.contentEditable = 'false'; // To support Safari
-
-        domStyle.setProperty('-webkit-user-select', 'none');
-      }
     }
 
     subTreeTextContent += text;
@@ -1699,7 +1738,7 @@ function isLastChildLineBreakOrDecorator(children, nodeMap) {
   const childKey = children[children.length - 1];
   const node = nodeMap.get(childKey);
   return $isLineBreakNode(node) || $isDecoratorNode(node);
-} // If we end an element with a LinkBreakNode, then we need to add an additional <br>
+} // If we end an element with a LineBreakNode, then we need to add an additional <br>
 
 
 function reconcileElementTerminatingLineBreak(prevChildren, nextChildren, dom) {
@@ -2196,7 +2235,7 @@ function onSelectionChange(domSelection, editor, isActive) {
 
       if (selection.isCollapsed()) {
         // Badly interpreted range selection when collapsed - #1482
-        if (domSelection.type === 'Range') {
+        if (domSelection.type === 'Range' && domSelection.anchorNode === domSelection.focusNode) {
           selection.dirty = true;
         } // If we have marked a collapsed selection format, and we're
         // within the given time range – then attempt to use that format
@@ -2294,7 +2333,7 @@ function $applyTargetRange(selection, event) {
 }
 
 function $canRemoveText(anchorNode, focusNode) {
-  return anchorNode !== focusNode || $isElementNode(anchorNode) || $isElementNode(focusNode) || !$isTokenOrInert(anchorNode) || !$isTokenOrInert(focusNode);
+  return anchorNode !== focusNode || $isElementNode(anchorNode) || $isElementNode(focusNode) || !anchorNode.isToken() || !focusNode.isToken();
 }
 
 function isPossiblyAndroidKeyPress(timeStamp) {
@@ -2332,7 +2371,7 @@ function onBeforeInput(event, editor) {
 
       if ($isRangeSelection(selection)) {
         // Used for handling backspace in Android.
-        if (isPossiblyAndroidKeyPress(event.timeStamp) && selection.anchor.key === selection.focus.key) {
+        if (isPossiblyAndroidKeyPress(event.timeStamp) && editor.isComposing() && selection.anchor.key === selection.focus.key) {
           $setCompositionKey(null);
           lastKeyDownTimeStamp = 0; // Fixes an Android bug where selection flickers when backspacing
 
@@ -3173,6 +3212,28 @@ class NodeSelection {
   insertText() {// Do nothing?
   }
 
+  insertNodes(nodes, selectStart) {
+    const selectedNodes = this.getNodes();
+    const selectedNodesLength = selectedNodes.length;
+    const lastSelectedNode = selectedNodes[selectedNodesLength - 1];
+    let selectionAtEnd; // Insert nodes
+
+    if ($isTextNode(lastSelectedNode)) {
+      selectionAtEnd = lastSelectedNode.select();
+    } else {
+      const index = lastSelectedNode.getIndexWithinParent() + 1;
+      selectionAtEnd = lastSelectedNode.getParentOrThrow().select(index, index);
+    }
+
+    selectionAtEnd.insertNodes(nodes, selectStart); // Remove selected nodes
+
+    for (let i = 0; i < selectedNodesLength; i++) {
+      selectedNodes[i].remove();
+    }
+
+    return true;
+  }
+
   getNodes() {
     const cachedNodes = this._cachedNodes;
 
@@ -3225,7 +3286,7 @@ class GridSelection {
   }
 
   is(selection) {
-    if (!$isGridSelection(selection)) {
+    if (!DEPRECATED_$isGridSelection(selection)) {
       return false;
     }
 
@@ -3266,6 +3327,12 @@ class GridSelection {
   insertText() {// Do nothing?
   }
 
+  insertNodes(nodes, selectStart) {
+    const focusNode = this.focus.getNode();
+    const selection = $normalizeSelection(focusNode.select(0, focusNode.getChildrenSize()));
+    return selection.insertNodes(nodes, selectStart);
+  }
+
   getShape() {
     const anchorCellNode = $getNodeByKey(this.anchor.key);
 
@@ -3311,7 +3378,7 @@ class GridSelection {
     } = this.getShape();
     const gridNode = $getNodeByKey(this.gridKey);
 
-    if (!$isGridNode(gridNode)) {
+    if (!DEPRECATED_$isGridNode(gridNode)) {
       {
         throw Error(`getNodes: expected to find GridNode`);
       }
@@ -3324,7 +3391,7 @@ class GridSelection {
       const gridRowNode = gridRowNodes[r];
       nodesSet.add(gridRowNode);
 
-      if (!$isGridRowNode(gridRowNode)) {
+      if (!DEPRECATED_$isGridRowNode(gridRowNode)) {
         {
           throw Error(`getNodes: expected to find GridRowNode`);
         }
@@ -3335,7 +3402,7 @@ class GridSelection {
       for (let c = fromX; c <= toX; c++) {
         const gridCellNode = gridCellNodes[c];
 
-        if (!$isGridCellNode(gridCellNode)) {
+        if (!DEPRECATED_$isGridCellNode(gridCellNode)) {
           {
             throw Error(`getNodes: expected to find GridCellNode`);
           }
@@ -3376,7 +3443,7 @@ class GridSelection {
   }
 
 }
-function $isGridSelection(x) {
+function DEPRECATED_$isGridSelection(x) {
   return x instanceof GridSelection;
 }
 class RangeSelection {
@@ -3602,7 +3669,7 @@ class RangeSelection {
     if (this.isCollapsed() && startOffset === firstNodeTextLength && (firstNode.isSegmented() || firstNode.isToken() || !firstNode.canInsertTextAfter() || !firstNodeParent.canInsertTextAfter() && firstNode.getNextSibling() === null)) {
       let nextSibling = firstNode.getNextSibling();
 
-      if (!$isTextNode(nextSibling) || $isTokenOrInertOrSegmented(nextSibling)) {
+      if (!$isTextNode(nextSibling) || $isTokenOrSegmented(nextSibling)) {
         nextSibling = $createTextNode();
         nextSibling.setFormat(format);
 
@@ -3623,7 +3690,7 @@ class RangeSelection {
     } else if (this.isCollapsed() && startOffset === 0 && (firstNode.isSegmented() || firstNode.isToken() || !firstNode.canInsertTextBefore() || !firstNodeParent.canInsertTextBefore() && firstNode.getPreviousSibling() === null)) {
       let prevSibling = firstNode.getPreviousSibling();
 
-      if (!$isTextNode(prevSibling) || $isTokenOrInertOrSegmented(prevSibling)) {
+      if (!$isTextNode(prevSibling) || $isTokenOrSegmented(prevSibling)) {
         prevSibling = $createTextNode();
         prevSibling.setFormat(format);
 
@@ -3662,7 +3729,7 @@ class RangeSelection {
     }
 
     if (selectedNodesLength === 1) {
-      if ($isTokenOrInert(firstNode)) {
+      if (firstNode.isToken()) {
         const textNode = $createTextNode(text);
         textNode.select();
         firstNode.replace(textNode);
@@ -3731,7 +3798,7 @@ class RangeSelection {
 
 
       if (endPoint.type === 'text' && (endOffset !== 0 || lastNode.getTextContent() === '') || endPoint.type === 'element' && lastNode.getIndexWithinParent() < endOffset) {
-        if ($isTextNode(lastNode) && !$isTokenOrInert(lastNode) && endOffset !== lastNode.getTextContentSize()) {
+        if ($isTextNode(lastNode) && !lastNode.isToken() && endOffset !== lastNode.getTextContentSize()) {
           if (lastNode.isSegmented()) {
             const textNode = $createTextNode(lastNode.getTextContent());
             lastNode.replace(textNode);
@@ -3807,7 +3874,7 @@ class RangeSelection {
       // can have side-effects (in the case of hashtags).
 
 
-      if (!$isTokenOrInert(firstNode)) {
+      if (!firstNode.isToken()) {
         firstNode = firstNode.spliceText(startOffset, firstNodeTextLength - startOffset, text, true);
 
         if (firstNode.getTextContent() === '') {
@@ -3987,7 +4054,7 @@ class RangeSelection {
     // append them after the last node we're inserting.
 
     const nextSiblings = anchorNode.getNextSiblings();
-    const topLevelElement = $isRootNode(anchorNode) ? null : anchorNode.getTopLevelElementOrThrow();
+    const topLevelElement = $isRootOrShadowRoot(anchorNode) ? null : anchorNode.getTopLevelElementOrThrow();
 
     if ($isTextNode(anchorNode)) {
       const textContent = anchorNode.getTextContent();
@@ -4005,8 +4072,8 @@ class RangeSelection {
         siblings.push(anchorNode);
       } else if (anchorOffset === textContentLength) {
         target = anchorNode;
-      } else if ($isTokenOrInert(anchorNode)) {
-        // Do nothing if we're inside a token/inert node
+      } else if (anchorNode.isToken()) {
+        // Do nothing if we're inside a token node
         return false;
       } else {
         // If we started with a range selected grab the danglingText after the
@@ -4114,7 +4181,7 @@ class RangeSelection {
 
           target = topLevelElement;
         }
-      } else if (didReplaceOrMerge && !$isDecoratorNode(node) && $isRootNode(target.getParent())) {
+      } else if (didReplaceOrMerge && !$isDecoratorNode(node) && $isRootOrShadowRoot(target.getParent())) {
         {
           throw Error(`insertNodes: cannot insert a non-element into a root node`);
         }
@@ -4125,7 +4192,7 @@ class RangeSelection {
       if ($isElementNode(target) && !target.isInline()) {
         lastNode = node;
 
-        if ($isDecoratorNode(node) && node.isTopLevel()) {
+        if ($isDecoratorNode(node) && !node.isInline()) {
           target = target.insertAfter(node);
         } else if (!$isElementNode(node)) {
           const firstChild = target.getFirstChild();
@@ -4142,7 +4209,7 @@ class RangeSelection {
             continue;
           }
 
-          if ($isRootNode(target)) {
+          if ($isRootOrShadowRoot(target)) {
             const placementNode = target.getChildAtIndex(anchorOffset);
 
             if (placementNode !== null) {
@@ -4156,7 +4223,7 @@ class RangeSelection {
             target = target.insertAfter(node);
           }
         }
-      } else if (!$isElementNode(node) || $isElementNode(node) && node.isInline() || $isDecoratorNode(target) && target.isTopLevel()) {
+      } else if (!$isElementNode(node) || $isElementNode(node) && node.isInline() || $isDecoratorNode(target) && !target.isInline()) {
         lastNode = node;
         target = target.insertAfter(node);
       } else {
@@ -4213,7 +4280,7 @@ class RangeSelection {
           const sibling = siblings[i];
           const prevParent = sibling.getParentOrThrow();
 
-          if ($isElementNode(target) && !$isBlockElementNode(sibling) && !($isDecoratorNode(sibling) && sibling.isTopLevel())) {
+          if ($isElementNode(target) && !$isBlockElementNode(sibling) && !($isDecoratorNode(sibling) && !sibling.isInline())) {
             if (originalTarget === target) {
               target.append(sibling);
             } else {
@@ -4301,7 +4368,7 @@ class RangeSelection {
     } else {
       currentElement = anchor.getNode();
 
-      if ($isRootNode(currentElement)) {
+      if ($isRootOrShadowRoot(currentElement)) {
         const paragraph = $createParagraphNode();
         const child = currentElement.getChildAtIndex(anchorOffset);
         paragraph.select();
@@ -4837,7 +4904,7 @@ function resolveSelectionPointOnBoundary(point, isBackward, isCollapsed) {
         point.offset = prevSibling.getChildrenSize(); // @ts-expect-error: intentional
 
         point.type = 'element';
-      } else if ($isTextNode(prevSibling) && !prevSibling.isInert()) {
+      } else if ($isTextNode(prevSibling)) {
         point.key = prevSibling.__key;
         point.offset = prevSibling.getTextContent().length;
       }
@@ -4950,7 +5017,7 @@ function $createRangeSelection() {
 function $createNodeSelection() {
   return new NodeSelection(new Set());
 }
-function $createGridSelection() {
+function DEPRECATED_$createGridSelection() {
   const anchor = $createPoint('root', 0, 'element');
   const focus = $createPoint('root', 0, 'element');
   return new GridSelection('root', anchor, focus);
@@ -4960,7 +5027,7 @@ function internalCreateSelection(editor) {
   const lastSelection = currentEditorState._selection;
   const domSelection = getDOMSelection();
 
-  if ($isNodeSelection(lastSelection) || $isGridSelection(lastSelection)) {
+  if ($isNodeSelection(lastSelection) || DEPRECATED_$isGridSelection(lastSelection)) {
     return lastSelection.clone();
   }
 
@@ -5313,6 +5380,15 @@ function updateDOMSelection(prevSelection, nextSelection, editor, domSelection,
     // should happen.
   }
 }
+function $insertNodes(nodes, selectStart) {
+  let selection = $getSelection();
+
+  if (selection === null) {
+    selection = $getRoot().selectEnd();
+  }
+
+  return selection.insertNodes(nodes, selectStart);
+}
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -5693,7 +5769,6 @@ function commitPendingUpdates(editor) {
   const dirtyElements = editor._dirtyElements;
   const normalizedNodes = editor._normalizedNodes;
   const tags = editor._updateTags;
-  const pendingDecorators = editor._pendingDecorators;
   const deferred = editor._deferred;
 
   if (needsUpdate) {
@@ -5730,6 +5805,12 @@ function commitPendingUpdates(editor) {
   if (mutatedNodes !== null) {
     triggerMutationListeners(editor, currentEditorState, pendingEditorState, mutatedNodes, tags, dirtyLeaves);
   }
+  /**
+   * Capture pendingDecorators after garbage collecting detached decorators
+   */
+
+
+  const pendingDecorators = editor._pendingDecorators;
 
   if (pendingDecorators !== null) {
     editor._decorators = pendingDecorators;
@@ -6092,11 +6173,11 @@ function removeNode(nodeToRemove, restoreSelection, preserveEmptyParent) {
     $updateElementSelectionOnCreateDeleteNode(selection, parent, index, -1);
   }
 
-  if (!preserveEmptyParent && parent !== null && !$isRootNode(parent) && !parent.canBeEmpty() && parent.isEmpty()) {
+  if (!preserveEmptyParent && !$isRootOrShadowRoot(parent) && !parent.canBeEmpty() && parent.isEmpty()) {
     removeNode(parent, restoreSelection);
   }
 
-  if (parent !== null && $isRootNode(parent) && parent.isEmpty()) {
+  if ($isRootNode(parent) && parent.isEmpty()) {
     parent.selectEnd();
   }
 }
@@ -6236,7 +6317,7 @@ class LexicalNode {
     while (node !== null) {
       const parent = node.getParent();
 
-      if ($isRootNode(parent) && ($isElementNode(node) || $isDecoratorNode(node) && node.isTopLevel())) {
+      if ($isRootOrShadowRoot(parent)) {
         return node;
       }
 
@@ -6579,12 +6660,12 @@ class LexicalNode {
     return mutableNode;
   }
 
-  getTextContent(_includeInert, _includeDirectionless) {
+  getTextContent() {
     return '';
   }
 
-  getTextContentSize(includeInert, includeDirectionless) {
-    return this.getTextContent(includeInert, includeDirectionless).length;
+  getTextContentSize() {
+    return this.getTextContent().length;
   } // View
 
 
@@ -6798,7 +6879,7 @@ function errorOnTypeKlassMismatch(type, klass) {
 
   if (registeredNode === undefined) {
     {
-      throw Error(`Create node: Attempted to create node ${klass.name} that was not previously registered on the editor. You can use register your custom nodes.`);
+      throw Error(`Create node: Attempted to create node ${klass.name} that was not configured to be used on the editor.`);
     }
   }
 
@@ -6835,8 +6916,8 @@ class DecoratorNode extends LexicalNode {
     return false;
   }
 
-  isTopLevel() {
-    return false;
+  isInline() {
+    return true;
   }
 
 }
@@ -6925,7 +7006,7 @@ class ElementNode extends LexicalNode {
     return parent.getLastChild() === self;
   }
 
-  getAllTextNodes(includeInert) {
+  getAllTextNodes() {
     const textNodes = [];
     const self = this.getLatest();
     const children = self.__children;
@@ -6933,10 +7014,10 @@ class ElementNode extends LexicalNode {
     for (let i = 0; i < children.length; i++) {
       const childNode = $getNodeByKey(children[i]);
 
-      if ($isTextNode(childNode) && (includeInert || !childNode.isInert())) {
+      if ($isTextNode(childNode)) {
         textNodes.push(childNode);
       } else if ($isElementNode(childNode)) {
-        const subChildrenNodes = childNode.getAllTextNodes(includeInert);
+        const subChildrenNodes = childNode.getAllTextNodes();
         textNodes.push(...subChildrenNodes);
       }
     }
@@ -7032,6 +7113,18 @@ class ElementNode extends LexicalNode {
     return $getNodeByKey(children[childrenLength - 1]);
   }
 
+  getLastChildOrThrow() {
+    const lastChild = this.getLastChild();
+
+    if (lastChild === null) {
+      {
+        throw Error(`Expected node ${this.__key} to have a last child.`);
+      }
+    }
+
+    return lastChild;
+  }
+
   getChildAtIndex(index) {
     const self = this.getLatest();
     const children = self.__children;
@@ -7044,14 +7137,14 @@ class ElementNode extends LexicalNode {
     return $getNodeByKey(key);
   }
 
-  getTextContent(includeInert, includeDirectionless) {
+  getTextContent() {
     let textContent = '';
     const children = this.getChildren();
     const childrenLength = children.length;
 
     for (let i = 0; i < childrenLength; i++) {
       const child = children[i];
-      textContent += child.getTextContent(includeInert, includeDirectionless);
+      textContent += child.getTextContent();
 
       if ($isElementNode(child) && i !== childrenLength - 1 && !child.isInline()) {
         textContent += DOUBLE_LINE_BREAK;
@@ -7263,7 +7356,7 @@ class ElementNode extends LexicalNode {
         } // Cleanup if node can't be empty
 
 
-        if (writableSelfChildren.length === 0 && !this.canBeEmpty() && !$isRootNode(this)) {
+        if (writableSelfChildren.length === 0 && !this.canBeEmpty() && !$isRootOrShadowRoot(this)) {
           this.remove();
         }
       }
@@ -7331,6 +7424,14 @@ class ElementNode extends LexicalNode {
 
   isInline() {
     return false;
+  } // A shadow root is a Node that behaves like RootNode. The shadow root (and RootNode) mark the
+  // end of the hiercharchy, most implementations should treat it as there's nothing (upwards)
+  // beyond this point. For example, node.getTopElement(), when performed inside a TableCellNode
+  // will return the immediate first child underneath TableCellNode instead of RootNode.
+
+
+  isShadowRoot() {
+    return false;
   }
 
   canMergeWith(node) {
@@ -7376,16 +7477,16 @@ class RootNode extends ElementNode {
     }
   }
 
-  getTextContent(includeInert, includeDirectionless) {
+  getTextContent() {
     const cachedText = this.__cachedText;
 
     if (isCurrentlyReadOnlyMode() || getActiveEditor()._dirtyType === NO_DIRTY_NODES) {
-      if (cachedText !== null && (!includeInert || includeDirectionless !== false)) {
+      if (cachedText !== null) {
         return cachedText;
       }
     }
 
-    return super.getTextContent(includeInert, includeDirectionless);
+    return super.getTextContent();
   }
 
   remove() {
@@ -7836,11 +7937,6 @@ class TextNode extends LexicalNode {
     return self.__mode === IS_SEGMENTED;
   }
 
-  isInert() {
-    const self = this.getLatest();
-    return self.__mode === IS_INERT;
-  }
-
   isDirectionless() {
     const self = this.getLatest();
     return (self.__detail & IS_DIRECTIONLESS) !== 0;
@@ -7860,11 +7956,7 @@ class TextNode extends LexicalNode {
     return this.__type === 'text' && this.__mode === 0;
   }
 
-  getTextContent(includeInert, includeDirectionless) {
-    if (!includeInert && this.isInert() || includeDirectionless === false && this.isDirectionless()) {
-      return '';
-    }
-
+  getTextContent() {
     const self = this.getLatest();
     return self.__text;
   }
@@ -8383,18 +8475,17 @@ function convertBringAttentionToElement(domNode) {
   };
 }
 
-function convertTextDOMNode(domNode) {
-  const {
-    parentElement
-  } = domNode;
-  const textContent = domNode.textContent || '';
-  const textContentTrim = textContent.trim();
-  const isPre = parentElement != null && parentElement.tagName.toLowerCase() === 'pre';
+function convertTextDOMNode(domNode, _parent, preformatted) {
+  let textContent = domNode.textContent || '';
 
-  if (!isPre && textContentTrim.length === 0 && textContent.includes('\n')) {
-    return {
-      node: null
-    };
+  if (!preformatted && /\n/.test(textContent)) {
+    textContent = textContent.replace(/\r?\n/gm, ' ');
+
+    if (textContent.trim().length === 0) {
+      return {
+        node: null
+      };
+    }
   }
 
   return {
@@ -8491,6 +8582,24 @@ class ParagraphNode extends ElementNode {
       element.append(document.createElement('br'));
     }
 
+    if (element) {
+      const formatType = this.getFormatType();
+      element.style.textAlign = formatType;
+      const direction = this.getDirection();
+
+      if (direction) {
+        element.dir = direction;
+      }
+
+      const indent = this.getIndent();
+
+      if (indent > 0) {
+        // padding-inline-start is not widely supported in email HTML, but
+        // Lexical Reconciler uses padding-inline-start. Using text-indent instead.
+        element.style.textIndent = `${indent * 20}px`;
+      }
+    }
+
     return {
       element
     };
@@ -8648,7 +8757,7 @@ function createEditor(editorConfig) {
   const initialEditorState = config.editorState;
   const nodes = [RootNode, TextNode, LineBreakNode, ParagraphNode, ...(config.nodes || [])];
   const onError = config.onError;
-  const isEditable = config.editable || true;
+  const isEditable = config.editable !== undefined ? config.editable : true;
   let registeredNodes;
 
   if (editorConfig === undefined && activeEditor !== null) {
@@ -8763,7 +8872,9 @@ class LexicalEditor {
 
     this._key = createUID();
     this._onError = onError;
-    this._htmlConversions = htmlConversions;
+    this._htmlConversions = htmlConversions; // We don't actually make use of the `editable` argument above.
+    // Doing so, causes e2e tests around the lock to fail.
+
     this._editable = true;
     this._headless = false;
     this._window = null;
@@ -9080,7 +9191,7 @@ class LexicalEditor {
  * LICENSE file in the root directory of this source tree.
  *
  */
-const VERSION = '0.4.0';
+const VERSION = '0.4.1';
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -9091,7 +9202,7 @@ const VERSION = '0.4.0';
  */
 
 /** @noInheritDoc */
-class GridCellNode extends ElementNode {
+class DEPRECATED_GridCellNode extends ElementNode {
   /** @internal */
   constructor(colSpan, key) {
     super(key);
@@ -9105,8 +9216,8 @@ class GridCellNode extends ElementNode {
   }
 
 }
-function $isGridCellNode(node) {
-  return node instanceof GridCellNode;
+function DEPRECATED_$isGridCellNode(node) {
+  return node instanceof DEPRECATED_GridCellNode;
 }
 
 /**
@@ -9116,9 +9227,9 @@ function $isGridCellNode(node) {
  * LICENSE file in the root directory of this source tree.
  *
  */
-class GridNode extends ElementNode {}
-function $isGridNode(node) {
-  return node instanceof GridNode;
+class DEPRECATED_GridNode extends ElementNode {}
+function DEPRECATED_$isGridNode(node) {
+  return node instanceof DEPRECATED_GridNode;
 }
 
 /**
@@ -9128,12 +9239,12 @@ function $isGridNode(node) {
  * LICENSE file in the root directory of this source tree.
  *
  */
-class GridRowNode extends ElementNode {}
-function $isGridRowNode(node) {
-  return node instanceof GridRowNode;
+class DEPRECATED_GridRowNode extends ElementNode {}
+function DEPRECATED_$isGridRowNode(node) {
+  return node instanceof DEPRECATED_GridRowNode;
 }
 
-exports.$createGridSelection = $createGridSelection;
+exports.$addUpdateTag = $addUpdateTag;
 exports.$createLineBreakNode = $createLineBreakNode;
 exports.$createNodeSelection = $createNodeSelection;
 exports.$createParagraphNode = $createParagraphNode;
@@ -9145,18 +9256,18 @@ exports.$getNodeByKey = $getNodeByKey;
 exports.$getPreviousSelection = $getPreviousSelection;
 exports.$getRoot = $getRoot;
 exports.$getSelection = $getSelection;
+exports.$hasAncestor = $hasAncestor;
+exports.$insertNodes = $insertNodes;
 exports.$isDecoratorNode = $isDecoratorNode;
 exports.$isElementNode = $isElementNode;
-exports.$isGridCellNode = $isGridCellNode;
-exports.$isGridNode = $isGridNode;
-exports.$isGridRowNode = $isGridRowNode;
-exports.$isGridSelection = $isGridSelection;
+exports.$isInlineElementOrDecoratorNode = $isInlineElementOrDecoratorNode;
 exports.$isLeafNode = $isLeafNode;
 exports.$isLineBreakNode = $isLineBreakNode;
 exports.$isNodeSelection = $isNodeSelection;
 exports.$isParagraphNode = $isParagraphNode;
 exports.$isRangeSelection = $isRangeSelection;
 exports.$isRootNode = $isRootNode;
+exports.$isRootOrShadowRoot = $isRootOrShadowRoot;
 exports.$isTextNode = $isTextNode;
 exports.$nodesOfType = $nodesOfType;
 exports.$parseSerializedNode = $parseSerializedNode;
@@ -9179,6 +9290,14 @@ exports.CUT_COMMAND = CUT_COMMAND;
 exports.DELETE_CHARACTER_COMMAND = DELETE_CHARACTER_COMMAND;
 exports.DELETE_LINE_COMMAND = DELETE_LINE_COMMAND;
 exports.DELETE_WORD_COMMAND = DELETE_WORD_COMMAND;
+exports.DEPRECATED_$createGridSelection = DEPRECATED_$createGridSelection;
+exports.DEPRECATED_$isGridCellNode = DEPRECATED_$isGridCellNode;
+exports.DEPRECATED_$isGridNode = DEPRECATED_$isGridNode;
+exports.DEPRECATED_$isGridRowNode = DEPRECATED_$isGridRowNode;
+exports.DEPRECATED_$isGridSelection = DEPRECATED_$isGridSelection;
+exports.DEPRECATED_GridCellNode = DEPRECATED_GridCellNode;
+exports.DEPRECATED_GridNode = DEPRECATED_GridNode;
+exports.DEPRECATED_GridRowNode = DEPRECATED_GridRowNode;
 exports.DRAGEND_COMMAND = DRAGEND_COMMAND;
 exports.DRAGOVER_COMMAND = DRAGOVER_COMMAND;
 exports.DRAGSTART_COMMAND = DRAGSTART_COMMAND;
@@ -9188,9 +9307,6 @@ exports.ElementNode = ElementNode;
 exports.FOCUS_COMMAND = FOCUS_COMMAND;
 exports.FORMAT_ELEMENT_COMMAND = FORMAT_ELEMENT_COMMAND;
 exports.FORMAT_TEXT_COMMAND = FORMAT_TEXT_COMMAND;
-exports.GridCellNode = GridCellNode;
-exports.GridNode = GridNode;
-exports.GridRowNode = GridRowNode;
 exports.INDENT_CONTENT_COMMAND = INDENT_CONTENT_COMMAND;
 exports.INSERT_LINE_BREAK_COMMAND = INSERT_LINE_BREAK_COMMAND;
 exports.INSERT_PARAGRAPH_COMMAND = INSERT_PARAGRAPH_COMMAND;