lexical 0.4.1 → 0.5.1-next.0

package/Lexical.dev.js

@@ -13,50 +13,61 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-function createCommand() {
-  return {};
-}
-const SELECTION_CHANGE_COMMAND = createCommand();
-const CLICK_COMMAND = createCommand();
-const DELETE_CHARACTER_COMMAND = createCommand();
-const INSERT_LINE_BREAK_COMMAND = createCommand();
-const INSERT_PARAGRAPH_COMMAND = createCommand();
-const CONTROLLED_TEXT_INSERTION_COMMAND = createCommand();
-const PASTE_COMMAND = createCommand();
-const REMOVE_TEXT_COMMAND = createCommand();
-const DELETE_WORD_COMMAND = createCommand();
-const DELETE_LINE_COMMAND = createCommand();
-const FORMAT_TEXT_COMMAND = createCommand();
-const UNDO_COMMAND = createCommand();
-const REDO_COMMAND = createCommand();
-const KEY_ARROW_RIGHT_COMMAND = createCommand();
-const MOVE_TO_END = createCommand();
-const KEY_ARROW_LEFT_COMMAND = createCommand();
-const MOVE_TO_START = createCommand();
-const KEY_ARROW_UP_COMMAND = createCommand();
-const KEY_ARROW_DOWN_COMMAND = createCommand();
-const KEY_ENTER_COMMAND = createCommand();
-const KEY_SPACE_COMMAND = createCommand();
-const KEY_BACKSPACE_COMMAND = createCommand();
-const KEY_ESCAPE_COMMAND = createCommand();
-const KEY_DELETE_COMMAND = createCommand();
-const KEY_TAB_COMMAND = createCommand();
-const INDENT_CONTENT_COMMAND = createCommand();
-const OUTDENT_CONTENT_COMMAND = createCommand();
-const DROP_COMMAND = createCommand();
-const FORMAT_ELEMENT_COMMAND = createCommand();
-const DRAGSTART_COMMAND = createCommand();
-const DRAGOVER_COMMAND = createCommand();
-const DRAGEND_COMMAND = createCommand();
-const COPY_COMMAND = createCommand();
-const CUT_COMMAND = createCommand();
-const CLEAR_EDITOR_COMMAND = createCommand();
-const CLEAR_HISTORY_COMMAND = createCommand();
-const CAN_REDO_COMMAND = createCommand();
-const CAN_UNDO_COMMAND = createCommand();
-const FOCUS_COMMAND = createCommand();
-const BLUR_COMMAND = createCommand();
-const KEY_MODIFIER_COMMAND = createCommand();
+function createCommand(type) {
+  return {
+    type
+  } ;
+}
+const SELECTION_CHANGE_COMMAND = createCommand('SELECTION_CHANGE_COMMAND');
+const CLICK_COMMAND = createCommand('CLICK_COMMAND');
+const DELETE_CHARACTER_COMMAND = createCommand('DELETE_CHARACTER_COMMAND');
+const INSERT_LINE_BREAK_COMMAND = createCommand('INSERT_LINE_BREAK_COMMAND');
+const INSERT_PARAGRAPH_COMMAND = createCommand('INSERT_PARAGRAPH_COMMAND');
+const CONTROLLED_TEXT_INSERTION_COMMAND = createCommand('CONTROLLED_TEXT_INSERTION_COMMAND');
+const PASTE_COMMAND = createCommand('PASTE_COMMAND');
+const REMOVE_TEXT_COMMAND = createCommand('REMOVE_TEXT_COMMAND');
+const DELETE_WORD_COMMAND = createCommand('DELETE_WORD_COMMAND');
+const DELETE_LINE_COMMAND = createCommand('DELETE_LINE_COMMAND');
+const FORMAT_TEXT_COMMAND = createCommand('FORMAT_TEXT_COMMAND');
+const UNDO_COMMAND = createCommand('UNDO_COMMAND');
+const REDO_COMMAND = createCommand('REDO_COMMAND');
+const KEY_ARROW_RIGHT_COMMAND = createCommand('KEY_ARROW_RIGHT_COMMAND');
+const MOVE_TO_END = createCommand('MOVE_TO_END');
+const KEY_ARROW_LEFT_COMMAND = createCommand('KEY_ARROW_LEFT_COMMAND');
+const MOVE_TO_START = createCommand('MOVE_TO_START');
+const KEY_ARROW_UP_COMMAND = createCommand('KEY_ARROW_UP_COMMAND');
+const KEY_ARROW_DOWN_COMMAND = createCommand('KEY_ARROW_DOWN_COMMAND');
+const KEY_ENTER_COMMAND = createCommand('KEY_ENTER_COMMAND');
+const KEY_SPACE_COMMAND = createCommand('KEY_SPACE_COMMAND');
+const KEY_BACKSPACE_COMMAND = createCommand('KEY_BACKSPACE_COMMAND');
+const KEY_ESCAPE_COMMAND = createCommand('KEY_ESCAPE_COMMAND');
+const KEY_DELETE_COMMAND = createCommand('KEY_DELETE_COMMAND');
+const KEY_TAB_COMMAND = createCommand('KEY_TAB_COMMAND');
+const INDENT_CONTENT_COMMAND = createCommand('INDENT_CONTENT_COMMAND');
+const OUTDENT_CONTENT_COMMAND = createCommand('OUTDENT_CONTENT_COMMAND');
+const DROP_COMMAND = createCommand('DROP_COMMAND');
+const FORMAT_ELEMENT_COMMAND = createCommand('FORMAT_ELEMENT_COMMAND');
+const DRAGSTART_COMMAND = createCommand('DRAGSTART_COMMAND');
+const DRAGOVER_COMMAND = createCommand('DRAGOVER_COMMAND');
+const DRAGEND_COMMAND = createCommand('DRAGEND_COMMAND');
+const COPY_COMMAND = createCommand('COPY_COMMAND');
+const CUT_COMMAND = createCommand('CUT_COMMAND');
+const CLEAR_EDITOR_COMMAND = createCommand('CLEAR_EDITOR_COMMAND');
+const CLEAR_HISTORY_COMMAND = createCommand('CLEAR_HISTORY_COMMAND');
+const CAN_REDO_COMMAND = createCommand('CAN_REDO_COMMAND');
+const CAN_UNDO_COMMAND = createCommand('CAN_UNDO_COMMAND');
+const FOCUS_COMMAND = createCommand('FOCUS_COMMAND');
+const BLUR_COMMAND = createCommand('BLUR_COMMAND');
+const KEY_MODIFIER_COMMAND = createCommand('KEY_MODIFIER_COMMAND');
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+const CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -65,7 +76,8 @@ const KEY_MODIFIER_COMMAND = createCommand();
  * LICENSE file in the root directory of this source tree.
  *
  */
-const getSelection = () => window.getSelection();
+
+const getSelection = () => CAN_USE_DOM ? window.getSelection() : null;
 
 var getDOMSelection = getSelection;
 
@@ -76,7 +88,6 @@ var getDOMSelection = getSelection;
  * LICENSE file in the root directory of this source tree.
  *
  */
-const CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
 const documentMode = CAN_USE_DOM && 'documentMode' in document ? document.documentMode : null;
 const IS_APPLE = CAN_USE_DOM && /Mac|iPod|iPhone|iPad/.test(navigator.platform);
 const IS_FIREFOX = CAN_USE_DOM && /^(?!.*Seamonkey)(?=.*Firefox).*/i.test(navigator.userAgent);
@@ -104,8 +115,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 +176,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'
@@ -266,7 +275,7 @@ function $flushMutations$1(editor, mutations, observer) {
         const targetDOM = mutation.target;
         let targetNode = $getNearestNodeFromDOMNode(targetDOM, currentEditorState);
 
-        if ($isDecoratorNode(targetNode)) {
+        if (targetNode === null && targetDOM !== rootElement || $isDecoratorNode(targetNode)) {
           continue;
         }
 
@@ -490,11 +499,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 +666,10 @@ function $setCompositionKey(compositionKey) {
   }
 }
 function $getCompositionKey() {
+  if (isCurrentlyReadOnlyMode()) {
+    return null;
+  }
+
   const editor = getActiveEditor();
   return editor._compositionKey;
 }
@@ -886,7 +896,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 +928,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 +945,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 +973,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
@@ -1223,8 +1241,8 @@ function isFirefoxClipboardEvents(editor) {
   const inputType = event && event.inputType;
   return inputType === 'insertFromPaste' || inputType === 'insertFromPasteAsQuotation';
 }
-function dispatchCommand(editor, type, payload) {
-  return triggerCommandListeners(editor, type, payload);
+function dispatchCommand(editor, command, payload) {
+  return triggerCommandListeners(editor, command, payload);
 }
 function $textContentRequiresDoubleLinebreakAtEnd(node) {
   return !$isRootNode(node) && !node.isLastChild() && !node.isInline();
@@ -1274,6 +1292,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 +1328,6 @@ function $maybeMoveChildrenSelectionToParent(parentNode, offset = 0) {
 
   return selection;
 }
-
 function $hasAncestor(child, targetNode) {
   let parent = child.getParent();
 
@@ -1318,7 +1341,6 @@ function $hasAncestor(child, targetNode) {
 
   return false;
 }
-
 function getDefaultView(domElem) {
   const ownerDoc = domElem.ownerDocument;
   return ownerDoc && ownerDoc.defaultView || null;
@@ -1334,6 +1356,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 +1514,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 +1693,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 +1749,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) {
@@ -1853,7 +1903,9 @@ function reconcileNode(key, parentDOM) {
   }
 
   const isDirty = treatAllNodesAsDirty || activeDirtyLeaves.has(key) || activeDirtyElements.has(key);
-  const dom = getElementByKeyOrThrow(activeEditor$1, key);
+  const dom = getElementByKeyOrThrow(activeEditor$1, key); // If the node key points to the same instance in both states
+  // and isn't dirty, we just update the text content cache
+  // and return the existing DOM Node.
 
   if (prevNode === nextNode && !isDirty) {
     if ($isElementNode(prevNode)) {
@@ -1883,7 +1935,9 @@ function reconcileNode(key, parentDOM) {
     }
 
     return dom;
-  }
+  } // If the node key doesn't point to the same instance in both maps,
+  // it means it were cloned. If they're also dirty, we mark them as mutated.
+
 
   if (prevNode !== nextNode && isDirty) {
     setMutatedNode(mutatedNodes, activeEditorNodes, activeMutationListeners, nextNode, 'updated');
@@ -2062,6 +2116,8 @@ function reconcileNodeChildren(prevChildren, nextChildren, prevChildrenLength, n
 }
 
 function reconcileRoot(prevEditorState, nextEditorState, editor, dirtyType, dirtyElements, dirtyLeaves) {
+  // We cache text content to make retrieval more efficient.
+  // The cache must be rebuilt during reconciliation to account for any changes.
   subTreeTextContent = '';
   editorTextContent = '';
   subTreeDirectionedTextContent = ''; // Rather than pass around a load of arguments through the stack recursively
@@ -2078,7 +2134,9 @@ function reconcileRoot(prevEditorState, nextEditorState, editor, dirtyType, dirt
   activePrevNodeMap = prevEditorState._nodeMap;
   activeNextNodeMap = nextEditorState._nodeMap;
   activeEditorStateReadOnly = nextEditorState._readOnly;
-  activePrevKeyToDOMMap = new Map(editor._keyToDOMMap);
+  activePrevKeyToDOMMap = new Map(editor._keyToDOMMap); // We keep track of mutated nodes so we can trigger mutation
+  // listeners later in the update cycle.
+
   const currentMutatedNodes = new Map();
   mutatedNodes = currentMutatedNodes;
   reconcileNode('root', null); // We don't want a bunch of void checks throughout the scope
@@ -2196,7 +2254,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 +2352,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) {
@@ -3173,6 +3231,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,11 +3305,11 @@ class GridSelection {
   }
 
   is(selection) {
-    if (!$isGridSelection(selection)) {
+    if (!DEPRECATED_$isGridSelection(selection)) {
       return false;
     }
 
-    return this.gridKey === selection.gridKey && this.anchor.is(this.focus);
+    return this.gridKey === selection.gridKey && this.anchor.is(selection.anchor) && this.focus.is(selection.focus);
   }
 
   set(gridKey, anchorCellKey, focusCellKey) {
@@ -3266,6 +3346,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 +3397,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 +3410,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 +3421,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 +3462,7 @@ class GridSelection {
   }
 
 }
-function $isGridSelection(x) {
+function DEPRECATED_$isGridSelection(x) {
   return x instanceof GridSelection;
 }
 class RangeSelection {
@@ -3602,7 +3688,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 +3709,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 +3748,7 @@ class RangeSelection {
     }
 
     if (selectedNodesLength === 1) {
-      if ($isTokenOrInert(firstNode)) {
+      if (firstNode.isToken()) {
         const textNode = $createTextNode(text);
         textNode.select();
         firstNode.replace(textNode);
@@ -3731,7 +3817,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 +3893,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() === '') {
@@ -3964,7 +4050,30 @@ class RangeSelection {
   insertNodes(nodes, selectStart) {
     // If there is a range selected remove the text in it
     if (!this.isCollapsed()) {
-      this.removeText();
+      const selectionEnd = this.isBackward() ? this.anchor : this.focus;
+      const nextSibling = selectionEnd.getNode().getNextSibling();
+      const nextSiblingKey = nextSibling ? nextSibling.getKey() : null;
+      const prevSibling = selectionEnd.getNode().getPreviousSibling();
+      const prevSiblingKey = prevSibling ? prevSibling.getKey() : null;
+      this.removeText(); // If the selection has been moved to an adjacent inline element, create
+      // a temporary text node that we can insert the nodes after.
+
+      if (this.isCollapsed() && this.focus.type === 'element') {
+        let textNode;
+
+        if (this.focus.key === nextSiblingKey && this.focus.offset === 0) {
+          textNode = $createTextNode();
+          this.focus.getNode().insertBefore(textNode);
+        } else if (this.focus.key === prevSiblingKey && this.focus.offset === this.focus.getNode().getChildrenSize()) {
+          textNode = $createTextNode();
+          this.focus.getNode().insertAfter(textNode);
+        }
+
+        if (textNode) {
+          this.focus.set(textNode.__key, 0, 'text');
+          this.anchor.set(textNode.__key, 0, 'text');
+        }
+      }
     }
 
     const anchor = this.anchor;
@@ -3987,7 +4096,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 +4114,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 +4223,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 +4234,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();
@@ -4156,7 +4265,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 +4322,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 +4410,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 +4946,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 +5059,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 +5069,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 +5422,24 @@ 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);
+}
+function $getTextContent() {
+  const selection = $getSelection();
+
+  if (selection === null) {
+    return '';
+  }
+
+  return selection.getTextContent();
+}
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -5693,7 +5820,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 +5856,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;
@@ -5901,6 +6033,7 @@ function beginUpdate(editor, updateFn, options) {
   let onUpdate;
   let tag;
   let skipTransforms = false;
+  let discrete = false;
 
   if (options !== undefined) {
     onUpdate = options.onUpdate;
@@ -5911,6 +6044,7 @@ function beginUpdate(editor, updateFn, options) {
     }
 
     skipTransforms = options.skipTransforms || false;
+    discrete = options.discrete || false;
   }
 
   if (onUpdate) {
@@ -5926,6 +6060,7 @@ function beginUpdate(editor, updateFn, options) {
     editorStateWasCloned = true;
   }
 
+  pendingEditorState._flushSync = discrete;
   const previousActiveEditorState = activeEditorState;
   const previousReadOnlyMode = isReadOnlyMode;
   const previousActiveEditor = activeEditor;
@@ -6092,11 +6227,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 +6371,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 +6714,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
 
 
@@ -6593,6 +6728,17 @@ class LexicalNode {
       throw Error(`createDOM: base method not extended`);
     }
   }
+  /*
+   * This method is called when a node changes and should update the DOM
+   * in whatever way is necessary to make it align with any changes that might
+   * have happened during the update.
+   *
+   * Returning "true" here will cause lexical to unmount and recreate the DOM node
+   * (by calling createDOM). You would need to do this if the element tag changes,
+   * for instance.
+   *
+   * */
+
 
   updateDOM(_prevNode, _dom, _config) {
     {
@@ -6798,7 +6944,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 +6981,8 @@ class DecoratorNode extends LexicalNode {
     return false;
   }
 
-  isTopLevel() {
-    return false;
+  isInline() {
+    return true;
   }
 
 }
@@ -6925,7 +7071,7 @@ class ElementNode extends LexicalNode {
     return parent.getLastChild() === self;
   }
 
-  getAllTextNodes(includeInert) {
+  getAllTextNodes() {
     const textNodes = [];
     const self = this.getLatest();
     const children = self.__children;
@@ -6933,10 +7079,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 +7178,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 +7202,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 +7421,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();
         }
       }
@@ -7296,6 +7454,12 @@ class ElementNode extends LexicalNode {
   canIndent() {
     return true;
   }
+  /*
+   * This method controls the behavior of a the node during backwards
+   * deletion (i.e., backspace) when selection is at the beginning of
+   * the node (offset 0)
+   */
+
 
   collapseAtStart(selection) {
     return false;
@@ -7331,6 +7495,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 +7548,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() {
@@ -7752,7 +7924,6 @@ function setTextContent(nextText, dom, node) {
 
     if (nodeValue !== text) {
       if (isComposing || IS_FIREFOX) {
-        // We also use the diff composed text for general text in FF to avoid
         // We also use the diff composed text for general text in FF to avoid
         // the spellcheck red line from flickering.
         const [index, remove, insert] = diffComposedText(nodeValue, text);
@@ -7836,11 +8007,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 +8026,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 +8545,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 +8652,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
     };
@@ -8763,7 +8942,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;
@@ -9091,7 +9272,7 @@ const VERSION = '0.4.1';
  */
 
 /** @noInheritDoc */
-class GridCellNode extends ElementNode {
+class DEPRECATED_GridCellNode extends ElementNode {
   /** @internal */
   constructor(colSpan, key) {
     super(key);
@@ -9105,8 +9286,8 @@ class GridCellNode extends ElementNode {
   }
 
 }
-function $isGridCellNode(node) {
-  return node instanceof GridCellNode;
+function DEPRECATED_$isGridCellNode(node) {
+  return node instanceof DEPRECATED_GridCellNode;
 }
 
 /**
@@ -9116,9 +9297,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 +9309,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 +9326,19 @@ exports.$getNodeByKey = $getNodeByKey;
 exports.$getPreviousSelection = $getPreviousSelection;
 exports.$getRoot = $getRoot;
 exports.$getSelection = $getSelection;
+exports.$getTextContent = $getTextContent;
+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 +9361,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 +9378,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;