lexical 0.3.3 → 0.3.6

package/Lexical.dev.js

@@ -6,6 +6,58 @@
  */
 'use strict';
 
+/**
+ * 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.
+ *
+ */
+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();
+
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -96,6 +148,10 @@ const TEXT_TYPE_TO_FORMAT = {
   superscript: IS_SUPERSCRIPT,
   underline: IS_UNDERLINE
 };
+const DETAIL_TYPE_TO_DETAIL = {
+  directionless: IS_DIRECTIONLESS,
+  unmergeable: IS_UNMERGEABLE
+};
 const ELEMENT_TYPE_TO_FORMAT = {
   center: IS_ALIGN_CENTER,
   justify: IS_ALIGN_JUSTIFY,
@@ -148,7 +204,8 @@ function initTextEntryListener() {
 
 function isManagedLineBreak(dom, target, editor) {
   return (// @ts-expect-error: internal field
-    target.__lexicalLineBreak === dom || dom['__lexicalKey_' + editor._key] !== undefined
+    target.__lexicalLineBreak === dom || // @ts-ignore We intentionally add this to the Node.
+    dom[`__lexicalKey_${editor._key}`] !== undefined
   );
 }
 
@@ -170,7 +227,22 @@ function handleTextMutation(target, node, editor) {
   }
 
   const text = target.nodeValue;
-  $updateTextNodeFromDOMContent(node, text, anchorOffset, focusOffset, false);
+
+  if (text !== null) {
+    $updateTextNodeFromDOMContent(node, text, anchorOffset, focusOffset, false);
+  }
+}
+
+function shouldUpdateTextNodeFromMutation(selection, targetDOM, targetNode) {
+  if ($isRangeSelection(selection)) {
+    const anchorNode = selection.anchor.getNode();
+
+    if (anchorNode.is(targetNode) && selection.format !== anchorNode.getFormat()) {
+      return false;
+    }
+  }
+
+  return targetDOM.nodeType === DOM_TEXT_TYPE && targetNode.isAttached();
 }
 
 function $flushMutations$1(editor, mutations, observer) {
@@ -179,6 +251,7 @@ function $flushMutations$1(editor, mutations, observer) {
 
   try {
     updateEditor(editor, () => {
+      const selection = $getSelection() || getLastSelection(editor);
       const badDOMTargets = new Map();
       const rootElement = editor.getRootElement(); // We use the current edtior state, as that reflects what is
       // actually "on screen".
@@ -200,7 +273,7 @@ function $flushMutations$1(editor, mutations, observer) {
         if (type === 'characterData') {
           // Text mutations are deferred and passed to mutation listeners to be
           // processed outside of the Lexical engine.
-          if (shouldFlushTextMutations && targetDOM.nodeType === DOM_TEXT_TYPE && $isTextNode(targetNode) && targetNode.isAttached()) {
+          if (shouldFlushTextMutations && $isTextNode(targetNode) && shouldUpdateTextNodeFromMutation(selection, targetDOM, targetNode)) {
             handleTextMutation( // nodeType === DOM_TEXT_TYPE is a Text DOM node
             targetDOM, targetNode);
           }
@@ -315,8 +388,6 @@ function $flushMutations$1(editor, mutations, observer) {
         observer.takeRecords();
       }
 
-      const selection = $getSelection() || getLastSelection(editor);
-
       if (selection !== null) {
         if (shouldRevertSelection) {
           selection.dirty = true;
@@ -598,8 +669,9 @@ function $getNodeByKey(key, _editorState) {
   return node;
 }
 function getNodeFromDOMNode(dom, editorState) {
-  const editor = getActiveEditor();
-  const key = dom['__lexicalKey_' + editor._key];
+  const editor = getActiveEditor(); // @ts-ignore We intentionally add this to the Node.
+
+  const key = dom[`__lexicalKey_${editor._key}`];
 
   if (key !== undefined) {
     return $getNodeByKey(key, editorState);
@@ -664,7 +736,6 @@ function $setSelection(selection) {
   const editorState = getActiveEditorState();
 
   if (selection !== null) {
-    // @ts-ignore
     {
       if (Object.isFrozen(selection)) {
         {
@@ -709,7 +780,8 @@ dom, editor) {
   let node = dom;
 
   while (node != null) {
-    const key = node['__lexicalKey_' + editor._key];
+    // @ts-ignore We intentionally add this to the Node.
+    const key = node[`__lexicalKey_${editor._key}`];
 
     if (key !== undefined) {
       return key;
@@ -765,7 +837,9 @@ function $updateSelectedTextFromDOM(editor, isCompositionEnd, data) {
         focusOffset = offset;
       }
 
-      $updateTextNodeFromDOMContent(node, textContent, anchorOffset, focusOffset, isCompositionEnd);
+      if (textContent !== null) {
+        $updateTextNodeFromDOMContent(node, textContent, anchorOffset, focusOffset, isCompositionEnd);
+      }
     }
   }
 }
@@ -835,6 +909,11 @@ function $updateTextNodeFromDOMContent(textNode, textContent, anchorOffset, focu
   }
 }
 
+function $previousSiblingDoesNotAcceptText(node) {
+  const previousSibling = node.getPreviousSibling();
+  return ($isTextNode(previousSibling) || $isElementNode(previousSibling) && previousSibling.isInline()) && !previousSibling.canInsertTextAfter();
+}
+
 function $shouldInsertTextAfterOrBeforeTextNode(selection, node) {
   if (node.isSegmented()) {
     return true;
@@ -847,7 +926,7 @@ 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);
+  const shouldInsertTextBefore = offset === 0 && (!node.canInsertTextBefore() || !parent.canInsertTextBefore() || isToken || $previousSiblingDoesNotAcceptText(node));
   const shouldInsertTextAfter = node.getTextContentSize() === offset && (!node.canInsertTextBefore() || !parent.canInsertTextBefore() || isToken);
   return shouldInsertTextBefore || shouldInsertTextAfter;
 } // This function is used to determine if Lexical should attempt to override
@@ -961,6 +1040,8 @@ function isCopy(keyCode, shiftKey, metaKey, ctrlKey) {
   if (keyCode === 67) {
     return IS_APPLE ? metaKey : ctrlKey;
   }
+
+  return false;
 }
 function isCut(keyCode, shiftKey, metaKey, ctrlKey) {
   if (shiftKey) {
@@ -970,6 +1051,8 @@ function isCut(keyCode, shiftKey, metaKey, ctrlKey) {
   if (keyCode === 88) {
     return IS_APPLE ? metaKey : ctrlKey;
   }
+
+  return false;
 }
 
 function isArrowLeft(keyCode) {
@@ -1075,8 +1158,7 @@ function setMutatedNode(mutatedNodes, registeredNodes, mutationListeners, node,
 }
 function $nodesOfType(klass) {
   const editorState = getActiveEditorState();
-  const readOnly = editorState._readOnly; // @ts-expect-error TODO Replace Class utility type with InstanceType
-
+  const readOnly = editorState._readOnly;
   const klassType = klass.getType();
   const nodes = editorState._nodeMap;
   const nodesOfType = [];
@@ -1474,7 +1556,7 @@ function createNode(key, parentDOM, insertDOM) {
     const text = node.getTextContent();
 
     if ($isDecoratorNode(node)) {
-      const decorator = node.decorate(activeEditor$1);
+      const decorator = node.decorate(activeEditor$1, activeEditorConfig);
 
       if (decorator !== null) {
         reconcileDecorator(key, decorator);
@@ -1514,8 +1596,7 @@ function createNode(key, parentDOM, insertDOM) {
         parentDOM.appendChild(dom);
       }
     }
-  } // @ts-ignore
-
+  }
 
   {
     // Freeze the node in DEV to prevent accidental mutations
@@ -1597,10 +1678,9 @@ function reconcileBlockDirection(element, dom) {
 
       if (previousDirectionTheme !== undefined) {
         if (typeof previousDirectionTheme === 'string') {
-          const classNamesArr = previousDirectionTheme.split(' '); // @ts-expect-error: intentional
-
+          const classNamesArr = previousDirectionTheme.split(' ');
           previousDirectionTheme = theme[previousDirection] = classNamesArr;
-        } // @ts-expect-error: intentional
+        } // @ts-ignore: intentional
 
 
         classList.remove(...previousDirectionTheme);
@@ -1618,7 +1698,9 @@ function reconcileBlockDirection(element, dom) {
             nextDirectionTheme = theme[direction] = classNamesArr;
           }
 
-          classList.add(...nextDirectionTheme);
+          if (nextDirectionTheme !== undefined) {
+            classList.add(...nextDirectionTheme);
+          }
         } // Update direction
 
 
@@ -1790,7 +1872,7 @@ function reconcileNode(key, parentDOM) {
     const text = nextNode.getTextContent();
 
     if ($isDecoratorNode(nextNode)) {
-      const decorator = nextNode.decorate(activeEditor$1);
+      const decorator = nextNode.decorate(activeEditor$1, activeEditorConfig);
 
       if (decorator !== null) {
         reconcileDecorator(key, decorator);
@@ -1811,8 +1893,7 @@ function reconcileNode(key, parentDOM) {
     // Cache the latest text content.
     nextNode = nextNode.getWritable();
     nextNode.__cachedText = editorTextContent;
-  } // @ts-ignore
-
+  }
 
   {
     // Freeze the node in DEV to prevent accidental mutations
@@ -1941,20 +2022,30 @@ function reconcileRoot(prevEditorState, nextEditorState, editor, dirtyType, dirt
   // so instead we make it seem that these values are always set.
   // We also want to make sure we clear them down, otherwise we
   // can leak memory.
+  // @ts-ignore
+
+  activeEditor$1 = undefined; // @ts-ignore
+
+  activeEditorNodes = undefined; // @ts-ignore
+
+  activeDirtyElements = undefined; // @ts-ignore
+
+  activeDirtyLeaves = undefined; // @ts-ignore
+
+  activePrevNodeMap = undefined; // @ts-ignore
+
+  activeNextNodeMap = undefined; // @ts-ignore
+
+  activeEditorConfig = undefined; // @ts-ignore
+
+  activePrevKeyToDOMMap = undefined; // @ts-ignore
 
-  activeEditor$1 = undefined;
-  activeEditorNodes = undefined;
-  activeDirtyElements = undefined;
-  activeDirtyLeaves = undefined;
-  activePrevNodeMap = undefined;
-  activeNextNodeMap = undefined;
-  activeEditorConfig = undefined;
-  activePrevKeyToDOMMap = undefined;
   mutatedNodes = undefined;
   return currentMutatedNodes;
 }
 function storeDOMWithKey(key, dom, editor) {
-  const keyToDOMMap = editor._keyToDOMMap;
+  const keyToDOMMap = editor._keyToDOMMap; // @ts-ignore We intentionally add this to the Node.
+
   dom['__lexicalKey_' + editor._key] = key;
   keyToDOMMap.set(key, dom);
 }
@@ -1971,58 +2062,6 @@ function getPrevElementByKeyOrThrow(key) {
   return element;
 }
 
-/**
- * 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.
- *
- */
-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();
-
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -2035,10 +2074,11 @@ const ANDROID_COMPOSITION_LATENCY = 30;
 const rootElementEvents = [['keydown', onKeyDown], ['compositionstart', onCompositionStart], ['compositionend', onCompositionEnd], ['input', onInput], ['click', onClick], ['cut', PASS_THROUGH_COMMAND], ['copy', PASS_THROUGH_COMMAND], ['dragstart', PASS_THROUGH_COMMAND], ['dragover', PASS_THROUGH_COMMAND], ['paste', PASS_THROUGH_COMMAND], ['focus', PASS_THROUGH_COMMAND], ['blur', PASS_THROUGH_COMMAND], ['drop', PASS_THROUGH_COMMAND]];
 
 if (CAN_USE_BEFORE_INPUT) {
-  rootElementEvents.push(['beforeinput', onBeforeInput]);
+  rootElementEvents.push(['beforeinput', (event, editor) => onBeforeInput(event, editor)]);
 }
 
 let lastKeyDownTimeStamp = 0;
+let lastKeyCode = 0;
 let rootElementsRegistered = 0;
 let isSelectionChangeFromDOMUpdate = false;
 let isInsertLineBreak = false;
@@ -2046,7 +2086,7 @@ let isFirefoxEndingComposition = false;
 let collapsedSelectionFormat = [0, 0, 'root', 0];
 
 function shouldSkipSelectionChange(domNode, offset) {
-  return domNode !== null && domNode.nodeType === DOM_TEXT_TYPE && offset !== 0 && offset !== domNode.nodeValue.length;
+  return domNode !== null && domNode.nodeValue !== null && domNode.nodeType === DOM_TEXT_TYPE && offset !== 0 && offset !== domNode.nodeValue.length;
 }
 
 function onSelectionChange(domSelection, editor, isActive) {
@@ -2148,15 +2188,19 @@ function onClick(event, editor) {
       const anchor = selection.anchor;
       const anchorNode = anchor.getNode();
 
-      if (anchor.type === 'element' && anchor.offset === 0 && selection.isCollapsed() && !$isRootNode(anchorNode) && $getRoot().getChildrenSize() === 1 && anchorNode.getTopLevelElementOrThrow().isEmpty() && lastSelection !== null && selection.is(lastSelection)) {
+      if (domSelection && anchor.type === 'element' && anchor.offset === 0 && selection.isCollapsed() && !$isRootNode(anchorNode) && $getRoot().getChildrenSize() === 1 && anchorNode.getTopLevelElementOrThrow().isEmpty() && lastSelection !== null && selection.is(lastSelection)) {
         domSelection.removeAllRanges();
         selection.dirty = true;
       }
-    } else if ($isNodeSelection(selection) && domSelection.isCollapsed) {
+    } else if (domSelection && $isNodeSelection(selection) && domSelection.isCollapsed) {
       const domAnchor = domSelection.anchorNode; // If the user is attempting to click selection back onto text, then
       // we should attempt create a range selection.
+      // When we click on an empty paragraph node or the end of a paragraph that ends
+      // with an image/poll, the nodeType will be ELEMENT_NODE
 
-      if (domAnchor !== null && domAnchor.nodeType === DOM_TEXT_TYPE) {
+      const allowedNodeType = [DOM_ELEMENT_TYPE, DOM_TEXT_TYPE];
+
+      if (domAnchor !== null && allowedNodeType.includes(domAnchor.nodeType)) {
         const newSelection = internalCreateRangeSelection(lastSelection, domSelection, editor);
         $setSelection(newSelection);
       }
@@ -2180,6 +2224,10 @@ function $canRemoveText(anchorNode, focusNode) {
   return anchorNode !== focusNode || $isElementNode(anchorNode) || $isElementNode(focusNode) || !$isTokenOrInert(anchorNode) || !$isTokenOrInert(focusNode);
 }
 
+function isPossiblyAndroidKeyPress(timeStamp) {
+  return lastKeyCode === 229 && timeStamp < lastKeyDownTimeStamp + ANDROID_COMPOSITION_LATENCY;
+}
+
 function onBeforeInput(event, editor) {
   const inputType = event.inputType; // We let the browser do its own thing for composition.
 
@@ -2196,7 +2244,9 @@ function onBeforeInput(event, editor) {
     // during composition and see if the previous text contains
     // part of the composed text to work out the actual text that
     // we need to insert.
-    const composedText = event.data;
+    const composedText = event.data; // TODO: evaluate if this is Android only. It doesn't always seem
+    // to have any real impact, so could probably be refactored or removed
+    // for an alternative approach.
 
     if (composedText) {
       updateEditor(editor, () => {
@@ -2240,20 +2290,32 @@ function onBeforeInput(event, editor) {
         }
 
         $setSelection(prevSelection.clone());
-      } // Used for Android
+      }
 
+      if ($isRangeSelection(selection)) {
+        // Used for handling backspace in Android.
+        if (isPossiblyAndroidKeyPress(event.timeStamp) && selection.anchor.key === selection.focus.key) {
+          $setCompositionKey(null);
+          lastKeyDownTimeStamp = 0; // Fixes an Android bug where selection flickers when backspacing
 
-      $setCompositionKey(null);
-      event.preventDefault();
-      lastKeyDownTimeStamp = 0;
-      dispatchCommand(editor, DELETE_CHARACTER_COMMAND, true); // Fixes an Android bug where selection flickers when backspacing
+          setTimeout(() => {
+            updateEditor(editor, () => {
+              $setCompositionKey(null);
+            });
+          }, ANDROID_COMPOSITION_LATENCY);
 
-      setTimeout(() => {
-        updateEditor(editor, () => {
-          $setCompositionKey(null);
-        });
-      }, ANDROID_COMPOSITION_LATENCY);
-      return;
+          if ($isRangeSelection(selection)) {
+            const anchorNode = selection.anchor.getNode();
+            anchorNode.markDirty();
+            selection.format = anchorNode.getFormat();
+          }
+        } else {
+          event.preventDefault();
+          dispatchCommand(editor, DELETE_CHARACTER_COMMAND, false);
+        }
+
+        return;
+      }
     }
 
     if (!$isRangeSelection(selection)) {
@@ -2449,7 +2511,14 @@ function onInput(event, editor) {
         isFirefoxEndingComposition = false;
       }
 
-      dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, data); // This ensures consistency on Android.
+      dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, data);
+      const textLength = data.length; // Another hack for FF, as it's possible that the IME is still
+      // open, even though compositionend has already fired (sigh).
+
+      if (IS_FIREFOX && textLength > 1 && event.inputType === 'insertCompositionText' && !editor.isComposing()) {
+        selection.anchor.offset -= textLength;
+      } // This ensures consistency on Android.
+
 
       if (!IS_SAFARI && !IS_IOS && editor.isComposing()) {
         lastKeyDownTimeStamp = 0;
@@ -2459,7 +2528,7 @@ function onInput(event, editor) {
       $updateSelectedTextFromDOM(editor, false); // onInput always fires after onCompositionEnd for FF.
 
       if (isFirefoxEndingComposition) {
-        onCompositionEndImpl(editor, data);
+        onCompositionEndImpl(editor, data || undefined);
         isFirefoxEndingComposition = false;
       }
     } // Also flush any other mutations that might have occurred
@@ -2505,7 +2574,7 @@ function onCompositionEndImpl(editor, data) {
       const node = $getNodeByKey(compositionKey);
       const textNode = getDOMTextNode(editor.getElementByKey(compositionKey));
 
-      if (textNode !== null && $isTextNode(node)) {
+      if (textNode !== null && textNode.nodeValue !== null && $isTextNode(node)) {
         $updateTextNodeFromDOMContent(node, textNode.nodeValue, null, null, true);
       }
 
@@ -2548,6 +2617,7 @@ function onCompositionEnd(event, editor) {
 
 function onKeyDown(event, editor) {
   lastKeyDownTimeStamp = event.timeStamp;
+  lastKeyCode = event.keyCode;
 
   if (editor.isComposing()) {
     return;
@@ -2668,6 +2738,11 @@ const activeNestedEditorsMap = new Map();
 
 function onDocumentSelectionChange(event) {
   const selection = getDOMSelection();
+
+  if (!selection) {
+    return;
+  }
+
   const nextActiveEditor = getNearestEditorFromDOMNode(selection.anchorNode);
 
   if (nextActiveEditor === null) {
@@ -2767,7 +2842,7 @@ function removeRootElementEvents(rootElement) {
 
   const editor = rootElement.__lexicalEditor;
 
-  if (editor !== null || editor !== undefined) {
+  if (editor !== null && editor !== undefined) {
     cleanActiveNestedEditorsMap(editor); // @ts-expect-error: internal field
 
     rootElement.__lexicalEditor = null;
@@ -2813,7 +2888,6 @@ function markCollapsedSelectionFormat(format, offset, key, timeStamp) {
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 class Point {
   constructor(key, offset, type) {
     this._selection = null;
@@ -3445,11 +3519,12 @@ class RangeSelection {
     const lastIndex = selectedNodesLength - 1;
     let lastNode = selectedNodes[lastIndex];
 
-    if (this.isCollapsed() && startOffset === firstNodeTextLength && (firstNode.isSegmented() || firstNode.isToken() || !firstNode.canInsertTextAfter() || !firstNodeParent.canInsertTextAfter())) {
+    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)) {
         nextSibling = $createTextNode();
+        nextSibling.setFormat(format);
 
         if (!firstNodeParent.canInsertTextAfter()) {
           firstNodeParent.insertAfter(nextSibling);
@@ -3465,11 +3540,12 @@ class RangeSelection {
         this.insertText(text);
         return;
       }
-    } else if (this.isCollapsed() && startOffset === 0 && (firstNode.isSegmented() || firstNode.isToken() || !firstNode.canInsertTextBefore() || !firstNodeParent.canInsertTextBefore())) {
+    } 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)) {
         prevSibling = $createTextNode();
+        prevSibling.setFormat(format);
 
         if (!firstNodeParent.canInsertTextBefore()) {
           firstNodeParent.insertBefore(prevSibling);
@@ -3487,6 +3563,7 @@ class RangeSelection {
       }
     } else if (firstNode.isSegmented() && startOffset !== firstNodeTextLength) {
       const textNode = $createTextNode(firstNode.getTextContent());
+      textNode.setFormat(format);
       firstNode.replace(textNode);
       firstNode = textNode;
     } else if (!this.isCollapsed() && text !== '') {
@@ -3544,10 +3621,14 @@ class RangeSelection {
 
       if (firstNode.getTextContent() === '') {
         firstNode.remove();
-      } else if (firstNode.isComposing() && this.anchor.type === 'text') {
-        // When composing, we need to adjust the anchor offset so that
-        // we correctly replace that right range.
-        this.anchor.offset -= text.length;
+      } else if (this.anchor.type === 'text') {
+        if (firstNode.isComposing()) {
+          // When composing, we need to adjust the anchor offset so that
+          // we correctly replace that right range.
+          this.anchor.offset -= text.length;
+        } else {
+          this.format = firstNodeFormat;
+        }
       }
     } else {
       const markedNodeKeysForKeep = new Set([...firstNode.getParentKeys(), ...lastNode.getParentKeys()]); // We have to get the parent elements before the next section,
@@ -3683,10 +3764,19 @@ class RangeSelection {
   formatText(formatType) {
     // TODO I wonder if this methods use selection.extract() instead?
     const selectedNodes = this.getNodes();
-    const selectedNodesLength = selectedNodes.length;
-    const lastIndex = selectedNodesLength - 1;
-    let firstNode = selectedNodes[0];
-    let lastNode = selectedNodes[lastIndex];
+    const selectedTextNodes = [];
+
+    for (const selectedNode of selectedNodes) {
+      if ($isTextNode(selectedNode)) {
+        selectedTextNodes.push(selectedNode);
+      }
+    }
+
+    const selectedTextNodesLength = selectedTextNodes.length;
+    let firstIndex = 0;
+    const lastIndex = selectedTextNodesLength - 1;
+    let firstNode = selectedTextNodes[0];
+    let lastNode = selectedTextNodes[lastIndex];
 
     if (this.isCollapsed()) {
       this.toggleFormat(formatType); // When changing format, we should stop composition
@@ -3697,42 +3787,22 @@ class RangeSelection {
 
     const anchor = this.anchor;
     const focus = this.focus;
+    const anchorOffset = anchor.offset;
     const focusOffset = focus.offset;
-    let firstNextFormat = 0;
+    let firstNextFormat = firstNode.getFormatFlags(formatType, null);
     let firstNodeTextLength = firstNode.getTextContent().length;
-
-    for (let i = 0; i < selectedNodes.length; i++) {
-      const selectedNode = selectedNodes[i];
-
-      if ($isTextNode(selectedNode)) {
-        firstNextFormat = selectedNode.getFormatFlags(formatType, null);
-        break;
-      }
-    }
-
-    let anchorOffset = anchor.offset;
-    let startOffset;
-    let endOffset;
     const isBefore = anchor.isBefore(focus);
-    startOffset = isBefore ? anchorOffset : focusOffset;
-    endOffset = isBefore ? focusOffset : anchorOffset; // This is the case where the user only selected the very end of the
+    const endOffset = isBefore ? focusOffset : anchorOffset;
+    let startOffset = isBefore ? anchorOffset : focusOffset; // This is the case where the user only selected the very end of the
     // first node so we don't want to include it in the formatting change.
 
-    if (startOffset === firstNode.getTextContentSize()) {
-      let nextSibling = firstNode.getNextSibling();
-
-      if ($isElementNode(nextSibling) && nextSibling.isInline()) {
-        nextSibling = nextSibling.getFirstChild();
-      }
-
-      if ($isTextNode(nextSibling)) {
-        // we basically make the second node the firstNode, changing offsets accordingly
-        anchorOffset = 0;
-        startOffset = 0;
-        firstNode = nextSibling;
-        firstNodeTextLength = nextSibling.getTextContent().length;
-        firstNextFormat = firstNode.getFormatFlags(formatType, null);
-      }
+    if (startOffset === firstNode.getTextContentSize() && selectedTextNodes.length > 1) {
+      const nextNode = selectedTextNodes[1];
+      startOffset = 0;
+      firstIndex = 1;
+      firstNode = nextNode;
+      firstNodeTextLength = nextNode.getTextContentSize();
+      firstNextFormat = nextNode.getFormatFlags(formatType, null);
     } // This is the case where we only selected a single node
 
 
@@ -3743,10 +3813,8 @@ class RangeSelection {
           firstNode.select(startOffset, endOffset);
           this.format = firstNextFormat;
           return;
-        }
+        } // No actual text is selected, so do nothing.
 
-        startOffset = anchorOffset > focusOffset ? focusOffset : anchorOffset;
-        endOffset = anchorOffset > focusOffset ? anchorOffset : focusOffset; // No actual text is selected, so do nothing.
 
         if (startOffset === endOffset) {
           return;
@@ -3769,7 +3837,9 @@ class RangeSelection {
       } // multiple nodes selected.
 
     } else {
-      if ($isTextNode(firstNode)) {
+      // Note: startOffset !== firstNodeTextLength should only occur within rare programatic
+      // update functions; transforms normalization ensure there's no empty text nodes.
+      if ($isTextNode(firstNode) && startOffset !== firstNodeTextLength) {
         if (startOffset !== 0) {
           // the entire first node isn't selected, so split it
           [, firstNode] = firstNode.splitText(startOffset);
@@ -3795,11 +3865,12 @@ class RangeSelection {
 
           lastNode.setFormat(lastNextFormat);
         }
-      } // deal with all the nodes in between
+      }
 
+      this.format = firstNextFormat | lastNextFormat; // deal with all the nodes in between
 
-      for (let i = 1; i < lastIndex; i++) {
-        const selectedNode = selectedNodes[i];
+      for (let i = firstIndex + 1; i < lastIndex; i++) {
+        const selectedNode = selectedTextNodes[i];
         const selectedNodeKey = selectedNode.__key;
 
         if ($isTextNode(selectedNode) && selectedNodeKey !== firstNode.__key && selectedNodeKey !== lastNode.__key && !selectedNode.isToken()) {
@@ -3871,7 +3942,7 @@ class RangeSelection {
     siblings.push(...nextSiblings);
     const firstNode = nodes[0];
     let didReplaceOrMerge = false;
-    let lastNodeInserted = null; // Time to insert the nodes!
+    let lastNode = null; // Time to insert the nodes!
 
     for (let i = 0; i < nodes.length; i++) {
       const node = nodes[i];
@@ -3934,18 +4005,17 @@ class RangeSelection {
 
             if ($isElementNode(target)) {
               for (let s = 0; s < childrenLength; s++) {
-                lastNodeInserted = children[s];
-                target.append(lastNodeInserted);
+                target.append(children[s]);
               }
             } else {
               for (let s = childrenLength - 1; s >= 0; s--) {
-                lastNodeInserted = children[s];
-                target.insertAfter(lastNodeInserted);
+                target.insertAfter(children[s]);
               }
 
               target = target.getParentOrThrow();
             }
 
+            lastNode = children[childrenLength - 1];
             element.remove();
             didReplaceOrMerge = true;
 
@@ -3973,7 +4043,7 @@ class RangeSelection {
       didReplaceOrMerge = false;
 
       if ($isElementNode(target) && !target.isInline()) {
-        lastNodeInserted = node;
+        lastNode = node;
 
         if ($isDecoratorNode(node) && node.isTopLevel()) {
           target = target.insertAfter(node);
@@ -4006,8 +4076,8 @@ class RangeSelection {
             target = target.insertAfter(node);
           }
         }
-      } else if (!$isElementNode(node) || $isElementNode(node) && node.isInline() || $isDecoratorNode(target) && target.isTopLevel()) {
-        lastNodeInserted = node;
+      } else if (!$isElementNode(node) || $isElementNode(node) && node.isInline() || $isDecoratorNode(target) && target.isTopLevel() || $isLineBreakNode(target)) {
+        lastNode = node;
         target = target.insertAfter(node);
       } else {
         target = node.getParentOrThrow(); // Re-try again with the target being the parent
@@ -4036,7 +4106,7 @@ class RangeSelection {
     if ($isElementNode(target)) {
       // If the last node to be inserted was a text node,
       // then we should attempt to move selection to that.
-      const lastChild = $isTextNode(lastNodeInserted) ? lastNodeInserted : target.getLastDescendant();
+      const lastChild = $isTextNode(lastNode) ? lastNode : target.getLastDescendant();
 
       if (!selectStart) {
         // Handle moving selection to end for elements
@@ -4050,18 +4120,26 @@ class RangeSelection {
       }
 
       if (siblings.length !== 0) {
+        const originalTarget = target;
+
         for (let i = siblings.length - 1; i >= 0; i--) {
           const sibling = siblings[i];
           const prevParent = sibling.getParentOrThrow();
 
-          if ($isElementNode(target) && !$isElementNode(sibling)) {
-            target.append(sibling);
+          if ($isElementNode(target) && !$isBlockElementNode(sibling)) {
+            if (originalTarget === target) {
+              target.append(sibling);
+            } else {
+              target.insertBefore(sibling);
+            }
+
             target = sibling;
-          } else if (!$isElementNode(target) && !$isElementNode(sibling)) {
+          } else if (!$isElementNode(target) && !$isBlockElementNode(sibling)) {
             target.insertBefore(sibling);
             target = sibling;
           } else {
             if ($isElementNode(sibling) && !sibling.canInsertAfter(target)) {
+              // @ts-ignore The clone method does exist on the constructor.
               const prevParentClone = prevParent.constructor.clone(prevParent);
 
               if (!$isElementNode(prevParentClone)) {
@@ -4344,13 +4422,18 @@ class RangeSelection {
       }
     }
 
-    const domSelection = getDOMSelection(); // We use the DOM selection.modify API here to "tell" us what the selection
+    const domSelection = getDOMSelection();
+
+    if (!domSelection) {
+      return;
+    } // 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
     // from getTargetRanges(), and is also better than trying to do it ourselves
     // using Intl.Segmenter or other workarounds that struggle with word segments
     // and line segments (especially with word wrapping and non-Roman languages).
 
+
     $moveNativeSelection(domSelection, alter, isBackward ? 'backward' : 'forward', granularity); // Guard against no ranges
 
     if (domSelection.rangeCount > 0) {
@@ -4374,7 +4457,7 @@ class RangeSelection {
       let anchorNode = anchor.getNode();
 
       if (!isBackward && ( // Delete forward handle case
-      anchor.type === 'element' && anchor.offset === anchorNode.getChildrenSize() || anchor.type === 'text' && anchor.offset === anchorNode.getTextContentSize())) {
+      anchor.type === 'element' && $isElementNode(anchorNode) && anchor.offset === anchorNode.getChildrenSize() || anchor.type === 'text' && anchor.offset === anchorNode.getTextContentSize())) {
         const nextSibling = anchorNode.getNextSibling() || anchorNode.getParentOrThrow().getNextSibling();
 
         if ($isElementNode(nextSibling) && !nextSibling.canExtractContents()) {
@@ -4475,6 +4558,8 @@ function $swapPoints(selection) {
 }
 
 function $moveNativeSelection(domSelection, alter, direction, granularity) {
+  // @ts-expect-error Selection.modify() method applies a change to the current selection or cursor position,
+  // but is still non-standard in some browsers.
   domSelection.modify(alter, direction, granularity);
 }
 
@@ -4734,6 +4819,10 @@ function internalResolveSelectionPoints(anchorDOM, anchorOffset, focusDOM, focus
 
   normalizeSelectionPointsForBoundaries(resolvedAnchorPoint, resolvedFocusPoint, lastSelection);
   return [resolvedAnchorPoint, resolvedFocusPoint];
+}
+
+function $isBlockElementNode(node) {
+  return $isElementNode(node) && !node.isInline();
 } // This is used to make a selection when the existing
 // selection is null, i.e. forcing selection on the editor
 // when it current exists outside the editor.
@@ -4746,15 +4835,15 @@ function internalMakeRangeSelection(anchorKey, anchorOffset, focusKey, focusOffs
   editorState._selection = selection;
   return selection;
 }
-function $createEmptyRangeSelection() {
+function $createRangeSelection() {
   const anchor = $createPoint('root', 0, 'element');
   const focus = $createPoint('root', 0, 'element');
   return new RangeSelection(anchor, focus, 0);
 }
-function $createEmptyObjectSelection() {
+function $createNodeSelection() {
   return new NodeSelection(new Set());
 }
-function $createEmptyGridSelection() {
+function $createGridSelection() {
   const anchor = $createPoint('root', 0, 'element');
   const focus = $createPoint('root', 0, 'element');
   return new GridSelection('root', anchor, focus);
@@ -5082,7 +5171,7 @@ function updateDOMSelection(prevSelection, nextSelection, editor, domSelection,
   if (anchorOffset === nextAnchorOffset && focusOffset === nextFocusOffset && anchorDOMNode === nextAnchorNode && focusDOMNode === nextFocusNode && // Badly interpreted range selection when collapsed - #1482
   !(domSelection.type === 'Range' && isCollapsed)) {
     // If the root element does not have focus, ensure it has focus
-    if (activeElement === null || !rootElement.contains(activeElement)) {
+    if (rootElement !== null && (activeElement === null || !rootElement.contains(activeElement))) {
       rootElement.focus({
         preventScroll: true
       });
@@ -5101,7 +5190,7 @@ function updateDOMSelection(prevSelection, nextSelection, editor, domSelection,
   try {
     domSelection.setBaseAndExtent(nextAnchorNode, nextAnchorOffset, nextFocusNode, nextFocusOffset);
 
-    if (nextSelection.isCollapsed() && rootElement === activeElement) {
+    if (nextSelection.isCollapsed() && rootElement !== null && rootElement === activeElement) {
       scrollIntoViewIfNeeded(editor, anchor, rootElement, tags);
     }
 
@@ -5283,7 +5372,6 @@ function $applyAllTransforms(editorState, editor) {
 }
 
 function $parseSerializedNode(serializedNode) {
-  // $FlowFixMe: intentional cast to our internal type
   const internalSerializedNode = serializedNode;
   return $parseSerializedNodeImpl(internalSerializedNode, getActiveEditor()._nodes);
 }
@@ -5298,14 +5386,13 @@ function $parseSerializedNodeImpl(serializedNode, registeredNodes) {
     }
   }
 
-  const nodeClass = registeredNode.klass; // @ts-expect-error TODO Replace Class utility type with InstanceType
+  const nodeClass = registeredNode.klass;
 
   if (serializedNode.type !== nodeClass.getType()) {
     {
       throw Error(`LexicalNode: Node ${nodeClass.name} does not implement .importJSON().`);
     }
-  } // @ts-expect-error TODO Replace Class utility type with InstanceType
-
+  }
 
   const node = nodeClass.importJSON(serializedNode);
   const children = serializedNode.children;
@@ -5348,7 +5435,7 @@ function parseEditorState(serializedEditorState, editor, updateFn) {
     } // Make the editorState immutable
 
 
-    editorState._readOnly = true; // @ts-ignore
+    editorState._readOnly = true;
 
     {
       handleDEVOnlyPendingUpdateGuarantees(editorState);
@@ -5443,7 +5530,9 @@ function commitPendingUpdates(editor) {
       mutatedNodes = reconcileRoot(currentEditorState, pendingEditorState, editor, dirtyType, dirtyElements, dirtyLeaves);
     } catch (error) {
       // Report errors
-      editor._onError(error); // Reset editor and restore incoming editor state to the DOM
+      if (error instanceof Error) {
+        editor._onError(error);
+      } // Reset editor and restore incoming editor state to the DOM
 
 
       if (!isAttemptingToRecoverFromReconcilerError) {
@@ -5472,7 +5561,7 @@ function commitPendingUpdates(editor) {
     }
   }
 
-  pendingEditorState._readOnly = true; // @ts-ignore
+  pendingEditorState._readOnly = true;
 
   {
     handleDEVOnlyPendingUpdateGuarantees(pendingEditorState);
@@ -5576,6 +5665,7 @@ function triggerListeners(type, editor, isCurrentlyEnqueuingUpdates, ...payload)
     const listeners = Array.from(editor._listeners[type]);
 
     for (let i = 0; i < listeners.length; i++) {
+      // @ts-ignore
       listeners[i].apply(null, payload);
     }
   } finally {
@@ -5620,8 +5710,12 @@ function triggerEnqueuedUpdates(editor) {
   const queuedUpdates = editor._updates;
 
   if (queuedUpdates.length !== 0) {
-    const [updateFn, options] = queuedUpdates.shift();
-    beginUpdate(editor, updateFn, options);
+    const queuedUpdate = queuedUpdates.shift();
+
+    if (queuedUpdate) {
+      const [updateFn, options] = queuedUpdate;
+      beginUpdate(editor, updateFn, options);
+    }
   }
 }
 
@@ -5649,28 +5743,32 @@ function processNestedUpdates(editor, initialSkipTransforms) {
   // empty.
 
   while (queuedUpdates.length !== 0) {
-    const [nextUpdateFn, options] = queuedUpdates.shift();
-    let onUpdate;
-    let tag;
+    const queuedUpdate = queuedUpdates.shift();
 
-    if (options !== undefined) {
-      onUpdate = options.onUpdate;
-      tag = options.tag;
+    if (queuedUpdate) {
+      const [nextUpdateFn, options] = queuedUpdate;
+      let onUpdate;
+      let tag;
 
-      if (options.skipTransforms) {
-        skipTransforms = true;
-      }
+      if (options !== undefined) {
+        onUpdate = options.onUpdate;
+        tag = options.tag;
 
-      if (onUpdate) {
-        editor._deferred.push(onUpdate);
-      }
+        if (options.skipTransforms) {
+          skipTransforms = true;
+        }
 
-      if (tag) {
-        editor._updateTags.add(tag);
+        if (onUpdate) {
+          editor._deferred.push(onUpdate);
+        }
+
+        if (tag) {
+          editor._updateTags.add(tag);
+        }
       }
-    }
 
-    nextUpdateFn();
+      nextUpdateFn();
+    }
   }
 
   return skipTransforms;
@@ -5690,7 +5788,7 @@ function beginUpdate(editor, updateFn, options) {
       updateTags.add(tag);
     }
 
-    skipTransforms = options.skipTransforms;
+    skipTransforms = options.skipTransforms || false;
   }
 
   if (onUpdate) {
@@ -5762,7 +5860,9 @@ function beginUpdate(editor, updateFn, options) {
     }
   } catch (error) {
     // Report errors
-    editor._onError(error); // Restore existing editor state to the DOM
+    if (error instanceof Error) {
+      editor._onError(error);
+    } // Restore existing editor state to the DOM
 
 
     editor._pendingEditorState = currentEditorState;
@@ -5817,7 +5917,13 @@ function internalGetActiveEditor() {
   return activeEditor;
 }
 
-/* eslint-disable no-constant-condition */
+/**
+ * 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.
+ *
+ */
 function removeNode(nodeToRemove, restoreSelection, preserveEmptyParent) {
   errorOnReadOnly();
   const key = nodeToRemove.__key;
@@ -5906,7 +6012,7 @@ class LexicalNode {
     // @ts-expect-error
     this.__type = this.constructor.getType();
     this.__parent = null;
-    $setNodeKey(this, key); // @ts-ignore
+    $setNodeKey(this, key);
 
     {
       if (this.__type !== 'root') {
@@ -6118,7 +6224,6 @@ class LexicalNode {
     const b = node.getParents();
 
     if ($isElementNode(this)) {
-      // @ts-expect-error
       a.unshift(this);
     }
 
@@ -6375,52 +6480,11 @@ class LexicalNode {
 
   exportDOM(editor) {
     const element = this.createDOM(editor._config, editor);
-    const serializedNode = this.exportJSON();
-    element.setAttribute('data-lexical-node-type', this.__type);
-    element.setAttribute('data-lexical-node-json', JSON.stringify(serializedNode));
-    element.setAttribute('data-lexical-editor-key', editor._key);
     return {
       element
     };
   }
 
-  static importDOM() {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const proto = this.prototype.constructor;
-    return {
-      // Catch-all key because we don't know the nodeName of the element returned by exportDOM.
-      '*': domNode => {
-        if (!(domNode instanceof HTMLElement)) return null;
-        const editorKey = domNode.getAttribute('data-lexical-editor-key');
-        const nodeType = domNode.getAttribute('data-lexical-node-type');
-        if (editorKey == null || nodeType == null) return null;
-        const editor = getActiveEditor();
-
-        if (editorKey === editor.getKey() && nodeType === proto.getType()) {
-          try {
-            const json = domNode.getAttribute('data-lexical-node-json');
-
-            if (json != null) {
-              const serializedNode = JSON.parse(json);
-              const node = proto.importJSON(serializedNode);
-              return {
-                conversion: () => ({
-                  node
-                }),
-                // Max priority because of the 'data-lexical-node-type' attribute
-                // matching the one on node klass guarantees a match.
-                priority: 4
-              }; // eslint-disable-next-line no-empty
-            } // eslint-disable-next-line no-empty
-
-          } catch {}
-        }
-
-        return null;
-      }
-    };
-  }
-
   exportJSON() {
     {
       throw Error(`exportJSON: base method not extended`);
@@ -6639,7 +6703,7 @@ class DecoratorNode extends LexicalNode {
     super(key);
   }
 
-  decorate(editor) {
+  decorate(editor, config) {
     {
       throw Error(`decorate: base method not extended`);
     }
@@ -6872,8 +6936,12 @@ class ElementNode extends LexicalNode {
   }
 
   hasFormat(type) {
-    const formatFlag = ELEMENT_TYPE_TO_FORMAT[type];
-    return (this.getFormat() & formatFlag) !== 0;
+    if (type !== '') {
+      const formatFlag = ELEMENT_TYPE_TO_FORMAT[type];
+      return (this.getFormat() & formatFlag) !== 0;
+    }
+
+    return false;
   } // Mutators
 
 
@@ -6958,7 +7026,7 @@ class ElementNode extends LexicalNode {
   setFormat(type) {
     errorOnReadOnly();
     const self = this.getWritable();
-    self.__format = ELEMENT_TYPE_TO_FORMAT[type] || 0;
+    self.__format = type !== '' ? ELEMENT_TYPE_TO_FORMAT[type] : 0;
     return this;
   }
 
@@ -7108,7 +7176,7 @@ class ElementNode extends LexicalNode {
     return false;
   }
 
-  excludeFromCopy() {
+  excludeFromCopy(destination) {
     return false;
   }
 
@@ -7551,20 +7619,24 @@ function setTextContent(nextText, dom, node) {
     dom.textContent = text;
   } else {
     const nodeValue = firstChild.nodeValue;
-    if (nodeValue !== text) if (isComposing || IS_FIREFOX) {
-      // 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);
 
-      if (remove !== 0) {
-        // @ts-expect-error
-        firstChild.deleteData(index, remove);
-      } // @ts-expect-error
+    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);
 
+        if (remove !== 0) {
+          // @ts-expect-error
+          firstChild.deleteData(index, remove);
+        } // @ts-expect-error
 
-      firstChild.insertData(index, insert);
-    } else {
-      firstChild.nodeValue = text;
+
+        firstChild.insertData(index, insert);
+      } else {
+        firstChild.nodeValue = text;
+      }
     }
   }
 }
@@ -7817,19 +7889,21 @@ class TextNode extends LexicalNode {
 
   selectionTransform(prevSelection, nextSelection) {
     return;
-  }
+  } // TODO 0.4 This should just be a `string`.
+
 
   setFormat(format) {
     errorOnReadOnly();
     const self = this.getWritable();
-    self.__format = format;
+    self.__format = typeof format === 'string' ? TEXT_TYPE_TO_FORMAT[format] : format;
     return self;
-  }
+  } // TODO 0.4 This should just be a `string`.
+
 
   setDetail(detail) {
     errorOnReadOnly();
     const self = this.getWritable();
-    self.__detail = detail;
+    self.__detail = typeof detail === 'string' ? DETAIL_TYPE_TO_DETAIL[detail] : detail;
     return self;
   }
 
@@ -8119,11 +8193,13 @@ function convertSpanElement(domNode) {
   // domNode is a <span> since we matched it by nodeName
   const span = domNode; // Google Docs uses span tags + font-weight for bold text
 
-  const hasBoldFontWeight = span.style.fontWeight === '700'; // Google Docs uses span tags + text-decoration for strikethrough text
+  const hasBoldFontWeight = span.style.fontWeight === '700'; // Google Docs uses span tags + text-decoration: line-through for strikethrough text
 
   const hasLinethroughTextDecoration = span.style.textDecoration === 'line-through'; // Google Docs uses span tags + font-style for italic text
 
-  const hasItalicFontStyle = span.style.fontStyle === 'italic';
+  const hasItalicFontStyle = span.style.fontStyle === 'italic'; // Google Docs uses span tags + text-decoration: underline for underline text
+
+  const hasUnderlineTextDecoration = span.style.textDecoration === 'underline';
   return {
     forChild: lexicalNode => {
       if ($isTextNode(lexicalNode) && hasBoldFontWeight) {
@@ -8138,6 +8214,10 @@ function convertSpanElement(domNode) {
         lexicalNode.toggleFormat('italic');
       }
 
+      if ($isTextNode(lexicalNode) && hasUnderlineTextDecoration) {
+        lexicalNode.toggleFormat('underline');
+      }
+
       return lexicalNode;
     },
     node: null
@@ -8162,8 +8242,21 @@ 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';
+
+  if (!isPre && textContentTrim.length === 0 && textContent.includes('\n')) {
+    return {
+      node: null
+    };
+  }
+
   return {
-    node: $createTextNode(domNode.textContent)
+    node: $createTextNode(textContent)
   };
 }
 
@@ -8249,10 +8342,8 @@ class ParagraphNode extends ElementNode {
       element
     } = super.exportDOM(editor);
 
-    if (element) {
-      if (this.getTextContentSize() === 0) {
-        element.append(document.createElement('br'));
-      }
+    if (element && this.isEmpty()) {
+      element.append(document.createElement('br'));
     }
 
     return {
@@ -8376,10 +8467,9 @@ function initializeConversionCache(nodes) {
   const conversionCache = new Map();
   const handledConversions = new Set();
   nodes.forEach(node => {
-    // @ts-expect-error TODO Replace Class utility type with InstanceType
-    const importDOM = node.klass.importDOM.bind(node.klass); // debugger;
+    const importDOM = node.klass.importDOM != null ? node.klass.importDOM.bind(node.klass) : null;
 
-    if (handledConversions.has(importDOM)) {
+    if (importDOM == null || handledConversions.has(importDOM)) {
       return;
     }
 
@@ -8423,7 +8513,6 @@ function createEditor(editorConfig) {
 
     for (let i = 0; i < nodes.length; i++) {
       const klass = nodes[i]; // Ensure custom nodes implement required methods.
-      // @ts-ignore
 
       {
         const name = klass.name;
@@ -8446,7 +8535,7 @@ function createEditor(editorConfig) {
           if (proto instanceof DecoratorNode) {
             // eslint-disable-next-line no-prototype-builtins
             if (!proto.hasOwnProperty('decorate')) {
-              console.warn(`${this.constructor.name} must implement "decorate" method`);
+              console.warn(`${proto.constructor.name} must implement "decorate" method`);
             }
           }
 
@@ -8460,8 +8549,7 @@ function createEditor(editorConfig) {
             console.warn(`${name} should implement "exportJSON" method to ensure JSON and default HTML serialization works as expected`);
           }
         }
-      } // @ts-expect-error TODO Replace Class utility type with InstanceType
-
+      }
 
       const type = klass.getType();
       registeredNodes.set(type, {
@@ -8475,7 +8563,7 @@ function createEditor(editorConfig) {
     disableEvents,
     namespace,
     theme
-  }, onError, initializeConversionCache(registeredNodes), isReadOnly);
+  }, onError ? onError : console.error, initializeConversionCache(registeredNodes), isReadOnly);
 
   if (initialEditorState !== undefined) {
     editor._pendingEditorState = initialEditorState;
@@ -8614,7 +8702,6 @@ class LexicalEditor {
   }
 
   registerMutationListener(klass, listener) {
-    // @ts-expect-error TODO Replace Class utility type with InstanceType
     const registeredNode = this._nodes.get(klass.getType());
 
     if (registeredNode === undefined) {
@@ -8630,10 +8717,7 @@ class LexicalEditor {
     };
   }
 
-  registerNodeTransform( // There's no Flow-safe way to preserve the T in Transform<T>, but <T = LexicalNode> in the
-  // declaration below guarantees these are LexicalNodes.
-  klass, listener) {
-    // @ts-expect-error TODO Replace Class utility type with InstanceType
+  registerNodeTransform(klass, listener) {
     const type = klass.getType();
 
     const registeredNode = this._nodes.get(type);
@@ -8654,8 +8738,7 @@ class LexicalEditor {
 
   hasNodes(nodes) {
     for (let i = 0; i < nodes.length; i++) {
-      const klass = nodes[i]; // @ts-expect-error TODO Replace Class utility type with InstanceType
-
+      const klass = nodes[i];
       const type = klass.getType();
 
       if (!this._nodes.has(type)) {
@@ -8817,13 +8900,15 @@ class LexicalEditor {
   }
 
   setReadOnly(readOnly) {
-    this._readOnly = readOnly;
-    triggerListeners('readonly', this, true, readOnly);
+    if (this._readOnly !== readOnly) {
+      this._readOnly = readOnly;
+      triggerListeners('readonly', this, true, readOnly);
+    }
   }
 
   toJSON() {
     return {
-      editorState: this._editorState
+      editorState: this._editorState.toJSON()
     };
   }
 
@@ -8836,7 +8921,7 @@ class LexicalEditor {
  * LICENSE file in the root directory of this source tree.
  *
  */
-const VERSION = '0.3.3';
+const VERSION = '0.3.6';
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -8886,11 +8971,11 @@ function $isGridRowNode(node) {
   return node instanceof GridRowNode;
 }
 
-exports.$createGridSelection = $createEmptyGridSelection;
+exports.$createGridSelection = $createGridSelection;
 exports.$createLineBreakNode = $createLineBreakNode;
-exports.$createNodeSelection = $createEmptyObjectSelection;
+exports.$createNodeSelection = $createNodeSelection;
 exports.$createParagraphNode = $createParagraphNode;
-exports.$createRangeSelection = $createEmptyRangeSelection;
+exports.$createRangeSelection = $createRangeSelection;
 exports.$createTextNode = $createTextNode;
 exports.$getDecoratorNode = $getDecoratorNode;
 exports.$getNearestNodeFromDOMNode = $getNearestNodeFromDOMNode;