lexical 0.2.4 → 0.2.5

package/Lexical.dev.js

@@ -56,6 +56,7 @@ const IS_ALIGN_RIGHT = 3;
 const IS_ALIGN_JUSTIFY = 4; // Reconciliation
 
 const ZERO_WIDTH_CHAR = '\u200b';
+const DOUBLE_LINE_BREAK = '\n\n';
 const RTL = '\u0591-\u07FF\uFB1D-\uFDFD\uFE70-\uFEFC';
 const LTR = 'A-Za-z\u00C0-\u00D6\u00D8-\u00F6' + '\u00F8-\u02B8\u0300-\u0590\u0800-\u1FFF\u200E\u2C00-\uFB1C' + '\uFE00-\uFE6F\uFEFD-\uFFFF';
 const RTL_REGEX = new RegExp('^[^' + LTR + ']*[' + RTL + ']');
@@ -181,6 +182,9 @@ function getTextDirection(text) {
 
   return null;
 }
+function $isTokenOrInertOrSegmented(node) {
+  return $isTokenOrInert(node) || node.isSegmented();
+}
 function $isTokenOrInert(node) {
   return node.isToken() || node.isInert();
 }
@@ -322,21 +326,24 @@ function $setCompositionKey(compositionKey) {
   errorOnReadOnly();
   const editor = getActiveEditor();
   const previousCompositionKey = editor._compositionKey;
-  editor._compositionKey = compositionKey;
 
-  if (previousCompositionKey !== null) {
-    const node = $getNodeByKey(previousCompositionKey);
+  if (compositionKey !== previousCompositionKey) {
+    editor._compositionKey = compositionKey;
 
-    if (node !== null) {
-      node.getWritable();
+    if (previousCompositionKey !== null) {
+      const node = $getNodeByKey(previousCompositionKey);
+
+      if (node !== null) {
+        node.getWritable();
+      }
     }
-  }
 
-  if (compositionKey !== null) {
-    const node = $getNodeByKey(compositionKey);
+    if (compositionKey !== null) {
+      const node = $getNodeByKey(compositionKey);
 
-    if (node !== null) {
-      node.getWritable();
+      if (node !== null) {
+        node.getWritable();
+      }
     }
   }
 }
@@ -543,7 +550,9 @@ function $updateTextNodeFromDOMContent(textNode, textContent, anchorOffset, focu
           const editor = getActiveEditor();
           setTimeout(() => {
             editor.update(() => {
-              node.remove();
+              if (node.isAttached()) {
+                node.remove();
+              }
             });
           }, 20);
         } else {
@@ -852,6 +861,9 @@ function isFirefoxClipboardEvents() {
 function dispatchCommand(editor, type, payload) {
   return triggerCommandListeners(editor, type, payload);
 }
+function $textContentRequiresDoubleLinebreakAtEnd(node) {
+  return !$isRootNode(node) && !node.isLastChild() && !node.isInline();
+}
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -1091,6 +1103,7 @@ function internalCreateNodeFromParse(parsedNode, parsedNodeMap, editor, parentKe
     node.__style = parsedNode.__style;
     node.__mode = parsedNode.__mode;
     node.__detail = parsedNode.__detail;
+    node.__marks = parsedNode.__marks;
   } // The selection might refer to an old node whose key has changed. Produce a
   // new selection record with the old keys mapped to the new ones.
 
@@ -1141,8 +1154,8 @@ function internalCreateNodeFromParse(parsedNode, parsedNodeMap, editor, parentKe
       }
     } else if (originalSelection.type === 'grid') {
       const gridKey = originalSelection.gridKey;
-      const anchorCellKey = originalSelection.anchorCellKey;
-      const focusCellKey = originalSelection.focusCellKey;
+      const anchorCellKey = originalSelection.anchor.key;
+      const focusCellKey = originalSelection.focus.key;
 
       if (remappedSelection == null && (gridKey === parsedKey || gridKey === anchorCellKey || gridKey === focusCellKey)) {
         state.remappedSelection = remappedSelection = { ...originalSelection,
@@ -1156,11 +1169,11 @@ function internalCreateNodeFromParse(parsedNode, parsedNodeMap, editor, parentKe
         }
 
         if (anchorCellKey === parsedKey) {
-          remappedSelection.anchorCellKey = key;
+          remappedSelection.anchor.key = key;
         }
 
         if (focusCellKey === parsedKey) {
-          remappedSelection.focusCellKey = key;
+          remappedSelection.focus.key = key;
         }
       }
     }
@@ -1208,6 +1221,7 @@ const OUTDENT_CONTENT_COMMAND = createCommand();
 const DROP_COMMAND = createCommand();
 const FORMAT_ELEMENT_COMMAND = createCommand();
 const DRAGSTART_COMMAND = createCommand();
+const DRAGEND_COMMAND = createCommand();
 const COPY_COMMAND = createCommand();
 const CUT_COMMAND = createCommand();
 const CLEAR_EDITOR_COMMAND = createCommand();
@@ -1245,20 +1259,31 @@ if (CAN_USE_BEFORE_INPUT) {
 let lastKeyDownTimeStamp = 0;
 let rootElementsRegistered = 0;
 let isSelectionChangeFromReconcile = false;
+let isInsertLineBreak = 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;
+}
 
 function onSelectionChange(domSelection, editor, isActive) {
   if (isSelectionChangeFromReconcile) {
     isSelectionChangeFromReconcile = false;
     const {
       anchorNode,
-      focusNode
+      anchorOffset,
+      focusNode,
+      focusOffset
     } = domSelection; // If native DOM selection is on a DOM element, then
     // we should continue as usual, as Lexical's selection
     // may have normalized to a better child. If the DOM
     // element is a text node, we can safely apply this
     // optimization and skip the selection change entirely.
+    // We also need to check if the offset is at the boundary,
+    // because in this case, we might need to normalize to a
+    // sibling instead.
 
-    if (anchorNode !== null && focusNode !== null && anchorNode.nodeType === DOM_TEXT_TYPE && focusNode.nodeType === DOM_TEXT_TYPE) {
+    if (shouldSkipSelectionChange(anchorNode, anchorOffset) && shouldSkipSelectionChange(focusNode, focusOffset)) {
       return;
     }
   }
@@ -1273,19 +1298,45 @@ function onSelectionChange(domSelection, editor, isActive) {
 
     const selection = $getSelection(); // Update the selection format
 
-    if ($isRangeSelection(selection) && selection.isCollapsed()) {
-      // Badly interpreted range selection when collapsed - #1482
-      if (domSelection.type === 'Range') {
-        selection.dirty = true;
-      }
-
+    if ($isRangeSelection(selection)) {
       const anchor = selection.anchor;
+      const anchorNode = anchor.getNode();
+
+      if (selection.isCollapsed()) {
+        // Badly interpreted range selection when collapsed - #1482
+        if (domSelection.type === 'Range') {
+          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
+        // instead of getting the format from the anchor node.
+
+
+        const currentTimeStamp = window.event.timeStamp;
+        const [lastFormat, lastOffset, lastKey, timeStamp] = collapsedSelectionFormat;
+
+        if (currentTimeStamp < timeStamp + 200 && anchor.offset === lastOffset && anchor.key === lastKey) {
+          selection.format = lastFormat;
+        } else {
+          if (anchor.type === 'text') {
+            selection.format = anchorNode.getFormat();
+          } else if (anchor.type === 'element') {
+            selection.format = 0;
+          }
+        }
+      } else {
+        const focus = selection.focus;
+        const focusNode = focus.getNode();
+        let combinedFormat = 0;
 
-      if (anchor.type === 'text') {
-        const anchorNode = anchor.getNode();
-        selection.format = anchorNode.getFormat();
-      } else if (anchor.type === 'element') {
-        selection.format = 0;
+        if (anchor.type === 'text') {
+          combinedFormat |= anchorNode.getFormat();
+        }
+
+        if (focus.type === 'text' && !anchorNode.is(focusNode)) {
+          combinedFormat |= focusNode.getFormat();
+        }
+
+        selection.format = combinedFormat;
       }
     }
 
@@ -1306,7 +1357,7 @@ function onClick(event, editor) {
       const anchor = selection.anchor;
 
       if (anchor.type === 'element' && anchor.offset === 0 && selection.isCollapsed() && $getRoot().getChildrenSize() === 1 && anchor.getNode().getTopLevelElementOrThrow().isEmpty()) {
-        const lastSelection = editor.getEditorState()._selection;
+        const lastSelection = $getPreviousSelection();
 
         if (lastSelection !== null && selection.is(lastSelection)) {
           getDOMSelection().removeAllRanges();
@@ -1383,12 +1434,19 @@ function onBeforeInput(event, editor) {
   updateEditor(editor, () => {
     const selection = $getSelection();
 
-    if (!$isRangeSelection(selection)) {
-      return;
-    }
-
     if (inputType === 'deleteContentBackward') {
-      // Used for Android
+      if (selection === null) {
+        // Use previous selection
+        const prevSelection = $getPreviousSelection();
+
+        if (!$isRangeSelection(prevSelection)) {
+          return;
+        }
+
+        $setSelection(prevSelection.clone());
+      } // Used for Android
+
+
       $setCompositionKey(null);
       event.preventDefault();
       lastKeyDownTimeStamp = 0;
@@ -1402,6 +1460,10 @@ function onBeforeInput(event, editor) {
       return;
     }
 
+    if (!$isRangeSelection(selection)) {
+      return;
+    }
+
     const data = event.data;
 
     if (!selection.dirty && selection.isCollapsed() && !$isRootNode(selection.anchor.getNode())) {
@@ -1417,7 +1479,7 @@ function onBeforeInput(event, editor) {
       if (data === '\n') {
         event.preventDefault();
         dispatchCommand(editor, INSERT_LINE_BREAK_COMMAND);
-      } else if (data === '\n\n') {
+      } else if (data === DOUBLE_LINE_BREAK) {
         event.preventDefault();
         dispatchCommand(editor, INSERT_PARAGRAPH_COMMAND);
       } else if (data == null && event.dataTransfer) {
@@ -1466,8 +1528,16 @@ function onBeforeInput(event, editor) {
       case 'insertParagraph':
         {
           // Used for Android
-          $setCompositionKey(null);
-          dispatchCommand(editor, INSERT_PARAGRAPH_COMMAND);
+          $setCompositionKey(null); // Some browsers do not provide the type "insertLineBreak".
+          // So instead, we need to infer it from the keyboard event.
+
+          if (isInsertLineBreak) {
+            isInsertLineBreak = false;
+            dispatchCommand(editor, INSERT_LINE_BREAK_COMMAND);
+          } else {
+            dispatchCommand(editor, INSERT_PARAGRAPH_COMMAND);
+          }
+
           break;
         }
 
@@ -1601,7 +1671,9 @@ function onCompositionStart(event, editor) {
 
       if ( // If it has been 30ms since the last keydown, then we should
       // apply the empty space heuristic.
-      event.timeStamp < lastKeyDownTimeStamp + ANDROID_COMPOSITION_LATENCY || anchor.type === 'element' || !selection.isCollapsed() || selection.anchor.getNode().getFormat() !== selection.format) {
+      event.timeStamp < lastKeyDownTimeStamp + ANDROID_COMPOSITION_LATENCY || // FF has issues around composing multibyte characters, so we also
+      // need to invoke the empty space heuristic below.
+      IS_FIREFOX && anchor.type === 'element' || !selection.isCollapsed() || selection.anchor.getNode().getFormat() !== selection.format) {
         // We insert an empty space, ready for the composition
         // to get inserted into the new node we create. If
         // we don't do this, Safari will fail on us because
@@ -1672,11 +1744,14 @@ function onKeyDown(event, editor) {
   } else if (isMoveDown(keyCode, ctrlKey, shiftKey, altKey, metaKey)) {
     dispatchCommand(editor, KEY_ARROW_DOWN_COMMAND, event);
   } else if (isLineBreak(keyCode, shiftKey)) {
+    isInsertLineBreak = true;
     dispatchCommand(editor, KEY_ENTER_COMMAND, event);
   } else if (isOpenLineBreak(keyCode, ctrlKey)) {
     event.preventDefault();
+    isInsertLineBreak = true;
     dispatchCommand(editor, INSERT_LINE_BREAK_COMMAND, true);
   } else if (isParagraph(keyCode, shiftKey)) {
+    isInsertLineBreak = false;
     dispatchCommand(editor, KEY_ENTER_COMMAND, event);
   } else if (isDeleteBackward(keyCode, altKey, metaKey, ctrlKey)) {
     if (isBackspace(keyCode)) {
@@ -1811,6 +1886,9 @@ function addRootElementEvents(rootElement, editor) {
           case 'dragstart':
             return dispatchCommand(editor, DRAGSTART_COMMAND, event);
 
+          case 'dragend':
+            return dispatchCommand(editor, DRAGEND_COMMAND, event);
+
           case 'focus':
             return dispatchCommand(editor, FOCUS_COMMAND, event);
 
@@ -1877,6 +1955,9 @@ function cleanActiveNestedEditorsMap(editor) {
 function markSelectionChangeFromReconcile() {
   isSelectionChangeFromReconcile = true;
 }
+function markCollapsedSelectionFormat(format, offset, key, timeStamp) {
+  collapsedSelectionFormat = [format, offset, key, timeStamp];
+}
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -1944,7 +2025,7 @@ function setTextAlign(domStyle, value) {
 }
 
 function setElementIndent(dom, indent) {
-  dom.style.setProperty('padding-inline-start', indent === 0 ? '' : indent * 40 + 'px');
+  dom.style.setProperty('padding-inline-start', indent === 0 ? '' : indent * 20 + 'px');
 }
 
 function setElementFormat(dom, format) {
@@ -2005,6 +2086,11 @@ function createNode(key, parentDOM, insertDOM) {
     }
 
     reconcileElementTerminatingLineBreak(null, children, dom);
+
+    if ($textContentRequiresDoubleLinebreakAtEnd(node)) {
+      subTreeTextContent += DOUBLE_LINE_BREAK;
+      editorTextContent += DOUBLE_LINE_BREAK;
+    }
   } else {
     const text = node.getTextContent();
 
@@ -2176,12 +2262,12 @@ function reconcileBlockDirection(element, dom) {
 function reconcileChildrenWithDirection(prevChildren, nextChildren, element, dom) {
   const previousSubTreeDirectionTextContent = subTreeDirectionedTextContent;
   subTreeDirectionedTextContent = '';
-  reconcileChildren(prevChildren, nextChildren, dom);
+  reconcileChildren(element, prevChildren, nextChildren, dom);
   reconcileBlockDirection(element, dom);
   subTreeDirectionedTextContent = previousSubTreeDirectionTextContent;
 }
 
-function reconcileChildren(prevChildren, nextChildren, dom) {
+function reconcileChildren(element, prevChildren, nextChildren, dom) {
   const previousSubTreeTextContent = subTreeTextContent;
   subTreeTextContent = '';
   const prevChildrenLength = prevChildren.length;
@@ -2216,7 +2302,11 @@ function reconcileChildren(prevChildren, nextChildren, dom) {
       }
     }
   } else {
-    reconcileNodeChildren(prevChildren, nextChildren, prevChildrenLength, nextChildrenLength, dom);
+    reconcileNodeChildren(prevChildren, nextChildren, prevChildrenLength, nextChildrenLength, element, dom);
+  }
+
+  if ($textContentRequiresDoubleLinebreakAtEnd(element)) {
+    subTreeTextContent += DOUBLE_LINE_BREAK;
   } // $FlowFixMe: internal field
 
 
@@ -2311,6 +2401,11 @@ function reconcileNode(key, parentDOM) {
         reconcileElementTerminatingLineBreak(prevChildren, nextChildren, dom);
       }
     }
+
+    if ($textContentRequiresDoubleLinebreakAtEnd(nextNode)) {
+      subTreeTextContent += DOUBLE_LINE_BREAK;
+      editorTextContent += DOUBLE_LINE_BREAK;
+    }
   } else {
     const text = nextNode.getTextContent();
 
@@ -2320,6 +2415,9 @@ function reconcileNode(key, parentDOM) {
       if (decorator !== null) {
         reconcileDecorator(key, decorator);
       }
+
+      subTreeTextContent += text;
+      editorTextContent += text;
     } else if ($isTextNode(nextNode) && !nextNode.isDirectionless()) {
       // Handle text content, for LTR, LTR cases.
       subTreeDirectionedTextContent += text;
@@ -2368,7 +2466,7 @@ function getNextSibling(element) {
   return element.nextSibling;
 }
 
-function reconcileNodeChildren(prevChildren, nextChildren, prevChildrenLength, nextChildrenLength, dom) {
+function reconcileNodeChildren(prevChildren, nextChildren, prevChildrenLength, nextChildrenLength, element, dom) {
   const prevEndIndex = prevChildrenLength - 1;
   const nextEndIndex = nextChildrenLength - 1;
   let prevChildrenSet;
@@ -2582,11 +2680,15 @@ function reconcileSelection(prevSelection, nextSelection, editor, domSelection)
   const focusDOM = getElementByKeyOrThrow(editor, focusKey);
   const nextAnchorOffset = anchor.offset;
   const nextFocusOffset = focus.offset;
+  const nextFormat = nextSelection.format;
+  const isCollapsed = nextSelection.isCollapsed();
   let nextAnchorNode = anchorDOM;
   let nextFocusNode = focusDOM;
+  let anchorFormatChanged = false;
 
   if (anchor.type === 'text') {
     nextAnchorNode = getDOMTextNode(anchorDOM);
+    anchorFormatChanged = anchor.getNode().getFormat() !== nextFormat;
   }
 
   if (focus.type === 'text') {
@@ -2597,20 +2699,31 @@ function reconcileSelection(prevSelection, nextSelection, editor, domSelection)
 
   if (nextAnchorNode === null || nextFocusNode === null) {
     return;
+  }
+
+  if (isCollapsed && (prevSelection === null || anchorFormatChanged || prevSelection.format !== nextFormat)) {
+    markCollapsedSelectionFormat(nextFormat, nextAnchorOffset, anchorKey, performance.now());
   } // Diff against the native DOM selection to ensure we don't do
-  // an unnecessary selection update.
+  // an unnecessary selection update. We also skip this check if
+  // we're moving selection to within an element, as this can
+  // sometimes be problematic around scrolling.
 
 
   if (anchorOffset === nextAnchorOffset && focusOffset === nextFocusOffset && anchorDOMNode === nextAnchorNode && focusDOMNode === nextFocusNode && // Badly interpreted range selection when collapsed - #1482
-  !(domSelection.type === 'Range' && nextSelection.isCollapsed())) {
+  !(domSelection.type === 'Range' && isCollapsed)) {
     // If the root element does not have focus, ensure it has focus
     if (rootElement !== null && (activeElement === null || !rootElement.contains(activeElement))) {
       rootElement.focus({
         preventScroll: true
       });
-    }
+    } // In Safari/iOS if we have selection on an element, then we also
+    // need to additionally set the DOM selection, otherwise a selectionchange
+    // event will not fire.
 
-    return;
+
+    if (!(IS_IOS || IS_SAFARI) || anchor.type !== 'element') {
+      return;
+    }
   } // Apply the updated selection to the DOM. Note: this will trigger
   // a "selectionchange" event, although it will be asynchronous.
 
@@ -2741,7 +2854,7 @@ function $normalizeAllDirtyTextNodes(editorState, editor) {
   for (const nodeKey of dirtyLeaves) {
     const node = nodeMap.get(nodeKey);
 
-    if ($isTextNode(node) && node.isSimpleText() && !node.isUnmergeable()) {
+    if ($isTextNode(node) && node.isAttached() && node.isSimpleText() && !node.isUnmergeable()) {
       $normalizeTextNode(node);
     }
   }
@@ -2777,7 +2890,7 @@ function $applyAllTransforms(editorState, editor) {
       for (const nodeKey of untransformedDirtyLeaves) {
         const node = nodeMap.get(nodeKey);
 
-        if ($isTextNode(node) && node.isSimpleText() && !node.isUnmergeable()) {
+        if ($isTextNode(node) && node.isAttached() && node.isSimpleText() && !node.isUnmergeable()) {
           $normalizeTextNode(node);
         }
 
@@ -3095,9 +3208,9 @@ function triggerDeferredUpdateCallbacks(editor) {
   }
 }
 
-function processNestedUpdates(editor) {
+function processNestedUpdates(editor, initialSkipTransforms) {
   const queuedUpdates = editor._updates;
-  let skipTransforms = false; // Updates might grow as we process them, we so we'll need
+  let skipTransforms = initialSkipTransforms || false; // Updates might grow as we process them, we so we'll need
   // to handle each update as we go until the updates array is
   // empty.
 
@@ -3175,7 +3288,7 @@ function beginUpdate(editor, updateFn, options) {
 
     const startingCompositionKey = editor._compositionKey;
     updateFn();
-    skipTransforms = processNestedUpdates(editor);
+    skipTransforms = processNestedUpdates(editor, skipTransforms);
     applySelectionTransforms(pendingEditorState, editor);
 
     if (editor._dirtyType !== NO_DIRTY_NODES) {
@@ -3536,10 +3649,6 @@ class Point {
     return aNode.isBefore(bNode);
   }
 
-  getCharacterOffset() {
-    return this.type === 'text' ? this.offset : 0;
-  }
-
   getNode() {
     const key = this.key;
     const node = $getNodeByKey(key);
@@ -3721,12 +3830,10 @@ function $isRangeSelection(x) {
   return x instanceof RangeSelection;
 }
 class GridSelection {
-  constructor(gridKey, anchorCellKey, focusCellKey) {
+  constructor(gridKey, anchor, focus) {
     this.gridKey = gridKey;
-    this.anchorCellKey = anchorCellKey;
-    this.anchor = $createPoint(anchorCellKey, 0, 'element');
-    this.focusCellKey = focusCellKey;
-    this.focus = $createPoint(focusCellKey, 0, 'element');
+    this.anchor = anchor;
+    this.focus = focus;
     this.dirty = false;
   }
 
@@ -3735,18 +3842,18 @@ class GridSelection {
       return false;
     }
 
-    return this.gridKey === selection.gridKey && this.anchorCellKey === selection.anchorCellKey && this.focusCellKey === selection.focusCellKey;
+    return this.gridKey === selection.gridKey && this.anchor.is(this.focus);
   }
 
   set(gridKey, anchorCellKey, focusCellKey) {
     this.dirty = true;
     this.gridKey = gridKey;
-    this.anchorCellKey = anchorCellKey;
-    this.focusCellKey = focusCellKey;
+    this.anchor.key = anchorCellKey;
+    this.focus.key = focusCellKey;
   }
 
   clone() {
-    return new GridSelection(this.gridKey, this.anchorCellKey, this.focusCellKey);
+    return new GridSelection(this.gridKey, this.anchor, this.focus);
   }
 
   isCollapsed() {
@@ -3757,6 +3864,10 @@ class GridSelection {
     return this.focus.isBefore(this.anchor);
   }
 
+  getCharacterOffsets() {
+    return getCharacterOffsets(this);
+  }
+
   extract() {
     return this.getNodes();
   }
@@ -3768,7 +3879,7 @@ class GridSelection {
   }
 
   getShape() {
-    const anchorCellNode = $getNodeByKey(this.anchorCellKey);
+    const anchorCellNode = $getNodeByKey(this.anchor.key);
 
     if (!anchorCellNode) {
       throw Error(`getNodes: expected to find AnchorNode`);
@@ -3776,7 +3887,7 @@ class GridSelection {
 
     const anchorCellNodeIndex = anchorCellNode.getIndexWithinParent();
     const anchorCelRoweIndex = anchorCellNode.getParentOrThrow().getIndexWithinParent();
-    const focusCellNode = $getNodeByKey(this.focusCellKey);
+    const focusCellNode = $getNodeByKey(this.focus.key);
 
     if (!focusCellNode) {
       throw Error(`getNodes: expected to find FocusNode`);
@@ -3907,7 +4018,7 @@ class RangeSelection {
     }
 
     if (firstNode.is(lastNode)) {
-      if ($isElementNode(firstNode)) {
+      if ($isElementNode(firstNode) && (firstNode.getChildrenSize() > 0 || firstNode.excludeFromCopy())) {
         return [];
       }
 
@@ -3935,8 +4046,7 @@ class RangeSelection {
     const anchor = this.anchor;
     const focus = this.focus;
     const isBefore = anchor.isBefore(focus);
-    const anchorOffset = anchor.getCharacterOffset();
-    const focusOffset = focus.getCharacterOffset();
+    const [anchorOffset, focusOffset] = getCharacterOffsets(this);
     let textContent = '';
     let prevWasElement = true;
 
@@ -4064,11 +4174,13 @@ class RangeSelection {
     const firstNodeText = firstNode.getTextContent();
     const firstNodeTextLength = firstNodeText.length;
     const firstNodeParent = firstNode.getParentOrThrow();
+    const lastIndex = selectedNodesLength - 1;
+    let lastNode = selectedNodes[lastIndex];
 
     if (this.isCollapsed() && startOffset === firstNodeTextLength && (firstNode.isSegmented() || firstNode.isToken() || !firstNode.canInsertTextAfter() || !firstNodeParent.canInsertTextAfter())) {
       let nextSibling = firstNode.getNextSibling();
 
-      if (!$isTextNode(nextSibling) || $isTokenOrInert(nextSibling) || nextSibling.isSegmented()) {
+      if (!$isTextNode(nextSibling) || $isTokenOrInertOrSegmented(nextSibling)) {
         nextSibling = $createTextNode();
 
         if (!firstNodeParent.canInsertTextAfter()) {
@@ -4088,7 +4200,7 @@ class RangeSelection {
     } else if (this.isCollapsed() && startOffset === 0 && (firstNode.isSegmented() || firstNode.isToken() || !firstNode.canInsertTextBefore() || !firstNodeParent.canInsertTextBefore())) {
       let prevSibling = firstNode.getPreviousSibling();
 
-      if (!$isTextNode(prevSibling) || $isTokenOrInert(prevSibling) || prevSibling.isSegmented()) {
+      if (!$isTextNode(prevSibling) || $isTokenOrInertOrSegmented(prevSibling)) {
         prevSibling = $createTextNode();
 
         if (!firstNodeParent.canInsertTextBefore()) {
@@ -4109,6 +4221,19 @@ class RangeSelection {
       const textNode = $createTextNode(firstNode.getTextContent());
       firstNode.replace(textNode);
       firstNode = textNode;
+    } else if (!this.isCollapsed() && text !== '') {
+      // When the firstNode or lastNode parents are elements that
+      // do not allow text to be inserted before or after, we first
+      // clear the content. Then we normalize selection, then insert
+      // the new content.
+      const lastNodeParent = lastNode.getParent();
+
+      if (!firstNodeParent.canInsertTextBefore() || !firstNodeParent.canInsertTextAfter() || $isElementNode(lastNodeParent) && (!lastNodeParent.canInsertTextBefore() || !lastNodeParent.canInsertTextAfter())) {
+        this.insertText('');
+        normalizeSelectionPointsForBoundaries(this.anchor, this.focus, null);
+        this.insertText(text);
+        return;
+      }
     }
 
     if (selectedNodesLength === 1) {
@@ -4157,8 +4282,6 @@ class RangeSelection {
         this.anchor.offset -= text.length;
       }
     } else {
-      const lastIndex = selectedNodesLength - 1;
-      let lastNode = selectedNodes[lastIndex];
       const markedNodeKeysForKeep = new Set([...firstNode.getParentKeys(), ...lastNode.getParentKeys()]);
       const firstElement = $isElementNode(firstNode) ? firstNode : firstNode.getParentOrThrow();
       const lastElement = $isElementNode(lastNode) ? lastNode : lastNode.getParentOrThrow(); // Handle mutations to the last node.
@@ -4174,7 +4297,13 @@ class RangeSelection {
           lastNode = lastNode.spliceText(0, endOffset, '');
           markedNodeKeysForKeep.add(lastNode.__key);
         } else {
-          lastNode.remove();
+          const lastNodeParent = lastNode.getParentOrThrow();
+
+          if (!lastNodeParent.canBeEmpty() && lastNodeParent.getChildrenSize() === 1) {
+            lastNodeParent.remove();
+          } else {
+            lastNode.remove();
+          }
         }
       } else {
         markedNodeKeysForKeep.add(lastNode.__key);
@@ -4283,10 +4412,9 @@ class RangeSelection {
 
     const anchor = this.anchor;
     const focus = this.focus;
-    const firstNodeText = firstNode.getTextContent();
-    const firstNodeTextLength = firstNodeText.length;
     const focusOffset = focus.offset;
     let firstNextFormat = 0;
+    let firstNodeTextLength = firstNode.getTextContent().length;
 
     for (let i = 0; i < selectedNodes.length; i++) {
       const selectedNode = selectedNodes[i];
@@ -4313,6 +4441,7 @@ class RangeSelection {
         anchorOffset = 0;
         startOffset = 0;
         firstNode = nextSibling;
+        firstNodeTextLength = nextSibling.getTextContent().length;
         firstNextFormat = firstNode.getFormatFlags(formatType, null);
       }
     } // This is the case where we only selected a single node
@@ -4812,6 +4941,10 @@ class RangeSelection {
     }
   }
 
+  getCharacterOffsets() {
+    return getCharacterOffsets(this);
+  }
+
   extract() {
     const selectedNodes = this.getNodes();
     const selectedNodesLength = selectedNodes.length;
@@ -4820,8 +4953,7 @@ class RangeSelection {
     const focus = this.focus;
     let firstNode = selectedNodes[0];
     let lastNode = selectedNodes[lastIndex];
-    const anchorOffset = anchor.getCharacterOffset();
-    const focusOffset = focus.getCharacterOffset();
+    const [anchorOffset, focusOffset] = getCharacterOffsets(this);
 
     if (selectedNodesLength === 0) {
       return [];
@@ -4899,6 +5031,16 @@ class RangeSelection {
           anchor.set(elementKey, offset, 'element');
         }
 
+        return;
+      } else {
+        const siblingKey = sibling.__key;
+        const offset = isBackward ? sibling.getTextContent().length : 0;
+        focus.set(siblingKey, offset, 'text');
+
+        if (collapse) {
+          anchor.set(siblingKey, offset, 'text');
+        }
+
         return;
       }
     }
@@ -5001,6 +5143,29 @@ function $isNodeSelection(x) {
   return x instanceof NodeSelection;
 }
 
+function getCharacterOffset(point) {
+  const offset = point.offset;
+
+  if (point.type === 'text') {
+    return offset;
+  } // $FlowFixMe: cast
+
+
+  const parent = point.getNode();
+  return offset === parent.getChildrenSize() ? parent.getTextContent().length : 0;
+}
+
+function getCharacterOffsets(selection) {
+  const anchor = selection.anchor;
+  const focus = selection.focus;
+
+  if (anchor.type === 'element' && focus.type === 'element' && anchor.key === focus.key && anchor.offset === focus.offset) {
+    return [0, 0];
+  }
+
+  return [getCharacterOffset(anchor), getCharacterOffset(focus)];
+}
+
 function $swapPoints(selection) {
   const focus = selection.focus;
   const anchor = selection.anchor;
@@ -5169,6 +5334,78 @@ function internalResolveSelectionPoint(dom, offset, lastPoint) {
   return $createPoint(resolvedNode.__key, resolvedOffset, 'text');
 }
 
+function resolveSelectionPointOnBoundary(point, isBackward, isCollapsed) {
+  const offset = point.offset;
+  const node = point.getNode();
+
+  if (offset === 0) {
+    const prevSibling = node.getPreviousSibling();
+    const parent = node.getParent();
+
+    if (!isBackward) {
+      if ($isElementNode(prevSibling) && !isCollapsed && prevSibling.isInline()) {
+        point.key = prevSibling.__key;
+        point.offset = prevSibling.getChildrenSize(); // $FlowFixMe: intentional
+
+        point.type = 'element';
+      } else if ($isTextNode(prevSibling) && !prevSibling.isInert()) {
+        point.key = prevSibling.__key;
+        point.offset = prevSibling.getTextContent().length;
+      }
+    } else if ((isCollapsed || !isBackward) && prevSibling === null && $isElementNode(parent) && parent.isInline()) {
+      const parentSibling = parent.getPreviousSibling();
+
+      if ($isTextNode(parentSibling)) {
+        point.key = parentSibling.__key;
+        point.offset = parentSibling.getTextContent().length;
+      }
+    }
+  } else if (offset === node.getTextContent().length) {
+    const nextSibling = node.getNextSibling();
+    const parent = node.getParent();
+
+    if (isBackward && $isElementNode(nextSibling) && nextSibling.isInline()) {
+      point.key = nextSibling.__key;
+      point.offset = 0; // $FlowFixMe: intentional
+
+      point.type = 'element';
+    } else if ((isCollapsed || isBackward) && nextSibling === null && $isElementNode(parent) && parent.isInline()) {
+      const parentSibling = parent.getNextSibling();
+
+      if ($isTextNode(parentSibling)) {
+        point.key = parentSibling.__key;
+        point.offset = 0;
+      }
+    }
+  }
+}
+
+function normalizeSelectionPointsForBoundaries(anchor, focus, lastSelection) {
+  if (anchor.type === 'text' && focus.type === 'text') {
+    const isBackward = anchor.isBefore(focus);
+    const isCollapsed = anchor.is(focus); // Attempt to normalize the offset to the previous sibling if we're at the
+    // start of a text node and the sibling is a text node or inline element.
+
+    resolveSelectionPointOnBoundary(anchor, isBackward, isCollapsed);
+    resolveSelectionPointOnBoundary(focus, !isBackward, isCollapsed);
+
+    if (isCollapsed) {
+      focus.key = anchor.key;
+      focus.offset = anchor.offset;
+      focus.type = anchor.type;
+    }
+
+    const editor = getActiveEditor();
+
+    if (editor.isComposing() && editor._compositionKey !== anchor.key && $isRangeSelection(lastSelection)) {
+      const lastAnchor = lastSelection.anchor;
+      const lastFocus = lastSelection.focus;
+      $setPointValues(anchor, lastAnchor.key, lastAnchor.offset, lastAnchor.type);
+      $setPointValues(focus, lastFocus.key, lastFocus.offset, lastFocus.type);
+    }
+  }
+}
+
 function internalResolveSelectionPoints(anchorDOM, anchorOffset, focusDOM, focusOffset, editor, lastSelection) {
   if (anchorDOM === null || focusDOM === null || !isSelectionWithinEditor(editor, anchorDOM, focusDOM)) {
     return null;
@@ -5184,48 +5421,10 @@ function internalResolveSelectionPoints(anchorDOM, anchorOffset, focusDOM, focus
 
   if (resolvedFocusPoint === null) {
     return null;
-  }
-
-  if (resolvedAnchorPoint.type === 'text' && resolvedFocusPoint.type === 'text') {
-    const resolvedAnchorNode = resolvedAnchorPoint.getNode();
-    const resolvedFocusNode = resolvedFocusPoint.getNode(); // Handle normalization of selection when it is at the boundaries.
-
-    const textContentSize = resolvedAnchorNode.getTextContentSize();
-    const resolvedAnchorOffset = resolvedAnchorPoint.offset;
-    const resolvedFocusOffset = resolvedFocusPoint.offset;
-
-    if (resolvedAnchorNode === resolvedFocusNode && resolvedAnchorOffset === resolvedFocusOffset) {
-      if (anchorOffset === 0) {
-        const prevSibling = resolvedAnchorNode.getPreviousSibling();
-
-        if ($isTextNode(prevSibling) && !prevSibling.isInert()) {
-          const offset = prevSibling.getTextContentSize();
-          const key = prevSibling.__key;
-          resolvedAnchorPoint.key = key;
-          resolvedFocusPoint.key = key;
-          resolvedAnchorPoint.offset = offset;
-          resolvedFocusPoint.offset = offset;
-        }
-      }
-    } else {
-      if (resolvedAnchorOffset === textContentSize) {
-        const nextSibling = resolvedAnchorNode.getNextSibling();
+  } // Handle normalization of selection when it is at the boundaries.
 
-        if ($isTextNode(nextSibling) && !nextSibling.isInert()) {
-          resolvedAnchorPoint.key = nextSibling.__key;
-          resolvedAnchorPoint.offset = 0;
-        }
-      }
-    }
-
-    if (editor.isComposing() && editor._compositionKey !== resolvedAnchorPoint.key && $isRangeSelection(lastSelection)) {
-      const lastAnchor = lastSelection.anchor;
-      const lastFocus = lastSelection.focus;
-      $setPointValues(resolvedAnchorPoint, lastAnchor.key, lastAnchor.offset, lastAnchor.type);
-      $setPointValues(resolvedFocusPoint, lastFocus.key, lastFocus.offset, lastFocus.type);
-    }
-  }
 
+  normalizeSelectionPointsForBoundaries(resolvedAnchorPoint, resolvedFocusPoint, lastSelection);
   return [resolvedAnchorPoint, resolvedFocusPoint];
 } // This is used to make a selection when the existing
 // selection is null, i.e. forcing selection on the editor
@@ -5248,7 +5447,9 @@ function $createEmptyObjectSelection() {
   return new NodeSelection(new Set());
 }
 function $createEmptyGridSelection() {
-  return new GridSelection('root', 'root', 'root');
+  const anchor = $createPoint('root', 0, 'element');
+  const focus = $createPoint('root', 0, 'element');
+  return new GridSelection('root', anchor, focus);
 }
 
 function getActiveEventType() {
@@ -5327,7 +5528,7 @@ function internalCreateSelectionFromParse(parsedSelection) {
     } else if (parsedSelection.type === 'node') {
       return new NodeSelection(new Set(parsedSelection.nodes));
     } else if (parsedSelection.type === 'grid') {
-      return new GridSelection(parsedSelection.gridKey, parsedSelection.anchorCellKey, parsedSelection.focusCellKey);
+      return new GridSelection(parsedSelection.gridKey, $createPoint(parsedSelection.anchor.key, parsedSelection.anchor.offset, parsedSelection.anchor.type), $createPoint(parsedSelection.focus.key, parsedSelection.focus.offset, parsedSelection.focus.type));
     }
   }
 
@@ -6071,10 +6272,12 @@ class LexicalNode {
       mutableNode.__format = latestNode.__format;
       mutableNode.__dir = latestNode.__dir;
     } else if ($isTextNode(latestNode) && $isTextNode(mutableNode)) {
+      const marks = latestNode.__marks;
       mutableNode.__format = latestNode.__format;
       mutableNode.__style = latestNode.__style;
       mutableNode.__mode = latestNode.__mode;
       mutableNode.__detail = latestNode.__detail;
+      mutableNode.__marks = marks === null ? marks : Array.from(marks);
     }
 
     cloneNotNeeded.add(key);
@@ -6095,23 +6298,20 @@ class LexicalNode {
   getTextContentSize(includeInert, includeDirectionless) {
     return this.getTextContent(includeInert, includeDirectionless).length;
   } // View
-  // $FlowFixMe: Revise typings for EditorContext
 
 
   createDOM(config, editor) {
     {
       throw Error(`createDOM: base method not extended`);
     }
-  } // $FlowFixMe: Revise typings for EditorContext
-
+  }
 
   updateDOM( // $FlowFixMe: TODO
   prevNode, dom, config) {
     {
       throw Error(`updateDOM: base method not extended`);
     }
-  } // $FlowFixMe: Revise typings for EditorContext
-
+  }
 
   exportDOM(editor) {
     if ($isDecoratorNode(this)) {
@@ -6428,6 +6628,12 @@ class ElementNode extends LexicalNode {
     return dirtyElements !== null && dirtyElements.has(this.__key);
   }
 
+  isLastChild() {
+    const self = this.getLatest();
+    const parent = self.getParentOrThrow();
+    return parent.getLastChild() === self;
+  }
+
   getAllTextNodes(includeInert) {
     const textNodes = [];
     const self = this.getLatest();
@@ -6562,7 +6768,7 @@ class ElementNode extends LexicalNode {
       textContent += child.getTextContent(includeInert, includeDirectionless);
 
       if ($isElementNode(child) && i !== childrenLength - 1 && !child.isInline()) {
-        textContent += '\n\n';
+        textContent += DOUBLE_LINE_BREAK;
       }
     }
 
@@ -6791,6 +6997,10 @@ class ElementNode extends LexicalNode {
     return false;
   }
 
+  canIndent() {
+    return true;
+  }
+
   collapseAtStart(selection) {
     return false;
   }
@@ -7011,8 +7221,16 @@ class EditorState {
         nodes: Array.from(selection._nodes),
         type: 'node'
       } : $isGridSelection(selection) ? {
-        anchorCellKey: selection.anchorCellKey,
-        focusCellKey: selection.focusCellKey,
+        anchor: {
+          key: selection.anchor.key,
+          offset: selection.anchor.offset,
+          type: selection.anchor.type
+        },
+        focus: {
+          key: selection.focus.key,
+          offset: selection.focus.offset,
+          type: selection.focus.type
+        },
         gridKey: selection.gridKey,
         type: 'grid'
       } : null
@@ -7078,6 +7296,44 @@ function $isLineBreakNode(node) {
   return node instanceof LineBreakNode;
 }
 
+/**
+ * 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 simpleDiffWithCursor(a, b, cursor) {
+  const aLength = a.length;
+  const bLength = b.length;
+  let left = 0; // number of same characters counting from left
+
+  let right = 0; // number of same characters counting from right
+  // Iterate left to the right until we find a changed character
+  // First iteration considers the current cursor position
+
+  while (left < aLength && left < bLength && a[left] === b[left] && left < cursor) {
+    left++;
+  } // Iterate right to the left until we find a changed character
+
+
+  while (right + left < aLength && right + left < bLength && a[aLength - right - 1] === b[bLength - right - 1]) {
+    right++;
+  } // Try to iterate left further to the right without caring about the current cursor position
+
+
+  while (right + left < aLength && right + left < bLength && a[left] === b[left]) {
+    left++;
+  }
+
+  return {
+    index: left,
+    insert: b.slice(left, bLength - right),
+    remove: aLength - left - right
+  };
+}
+
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -7226,6 +7482,42 @@ function createTextInnerDOM(innerDOM, node, innerTag, format, text, config) {
   }
 }
 
+function updateTextMarks(textNode, marks, offset, delCount, size) {
+  for (let i = 0; i < marks.length; i++) {
+    const {
+      id,
+      start,
+      end
+    } = marks[i];
+    let newStart = start;
+    let newEnd = end;
+
+    if (newStart !== null && newStart >= offset) {
+      if (offset + delCount >= newStart) {
+        newStart = offset + delCount;
+      }
+
+      newStart += size - delCount;
+    }
+
+    if (newEnd !== null && newEnd >= offset) {
+      if (offset + delCount >= newEnd) {
+        newEnd = offset;
+      }
+
+      newEnd += size - delCount;
+    }
+
+    if (newStart !== start || newEnd !== end) {
+      if (newStart === null && newEnd === null || newStart !== null && newEnd !== null && newStart >= newEnd) {
+        textNode.deleteMark(id);
+      } else {
+        textNode.setMark(id, newStart, newEnd);
+      }
+    }
+  }
+}
+
 class TextNode extends LexicalNode {
   static getType() {
     return 'text';
@@ -7242,6 +7534,7 @@ class TextNode extends LexicalNode {
     this.__style = '';
     this.__mode = 0;
     this.__detail = 0;
+    this.__marks = null;
   }
 
   getFormat() {
@@ -7249,6 +7542,23 @@ class TextNode extends LexicalNode {
     return self.__format;
   }
 
+  getMark(id) {
+    const self = this.getLatest();
+    const marks = self.__marks;
+
+    if (marks !== null) {
+      for (let i = 0; i < marks.length; i++) {
+        const mark = marks[i];
+
+        if (mark.id === id) {
+          return mark;
+        }
+      }
+    }
+
+    return null;
+  }
+
   getStyle() {
     const self = this.getLatest();
     return self.__style;
@@ -7302,7 +7612,6 @@ class TextNode extends LexicalNode {
     const format = self.__format;
     return toggleTextFormatType(format, type, alignWithFormat);
   } // View
-  // $FlowFixMe: Revise typings for EditorContext
 
 
   createDOM(config) {
@@ -7327,8 +7636,7 @@ class TextNode extends LexicalNode {
     }
 
     return dom;
-  } // $FlowFixMe: Revise typings for EditorContext
-
+  }
 
   updateDOM(prevNode, dom, config) {
     const nextText = this.__text;
@@ -7464,6 +7772,64 @@ class TextNode extends LexicalNode {
     return self;
   }
 
+  setMark(id, start, end) {
+    errorOnReadOnly();
+    const self = this.getWritable();
+    let marks = self.__marks;
+    let found = false;
+
+    if (marks === null) {
+      self.__marks = marks = [];
+    }
+
+    const nextMark = {
+      end,
+      id,
+      start
+    };
+
+    {
+      Object.freeze(nextMark);
+    }
+
+    for (let i = 0; i < marks.length; i++) {
+      const prevMark = marks[i];
+
+      if (prevMark.id === id) {
+        found = true;
+        marks.splice(i, 1, nextMark);
+        break;
+      }
+    }
+
+    if (!found) {
+      marks.push(nextMark);
+    }
+  }
+
+  deleteMark(id) {
+    errorOnReadOnly();
+    const self = this.getWritable();
+    const marks = self.__marks;
+
+    if (marks === null) {
+      return;
+    }
+
+    for (let i = 0; i < marks.length; i++) {
+      const prevMark = marks[i];
+
+      if (prevMark.id === id) {
+        marks.splice(i, 1);
+        break;
+      }
+    }
+
+    if (marks.length === 0) {
+      self.__marks = null;
+    }
+  }
+
   setMode(type) {
     errorOnReadOnly();
     const mode = TEXT_MODE_TO_TYPE[type];
@@ -7475,7 +7841,26 @@ class TextNode extends LexicalNode {
   setTextContent(text) {
     errorOnReadOnly();
     const writableSelf = this.getWritable();
-    writableSelf.__text = text;
+    const marks = writableSelf.__marks;
+
+    if (marks !== null) {
+      const selection = $getSelection();
+      let cursorOffset = text.length;
+
+      if ($isRangeSelection(selection) && selection.isCollapsed()) {
+        const anchor = selection.anchor;
+
+        if (anchor.key === this.__key) {
+          cursorOffset = anchor.offset;
+        }
+      }
+
+      const diff = simpleDiffWithCursor(writableSelf.__text, text, cursorOffset);
+      this.spliceText(diff.index, diff.remove, diff.insert);
+    } else {
+      writableSelf.__text = text;
+    }
+
     return writableSelf;
   }
 
@@ -7540,7 +7925,14 @@ class TextNode extends LexicalNode {
     }
 
     const updatedText = text.slice(0, index) + newText + text.slice(index + delCount);
-    return writableSelf.setTextContent(updatedText);
+    const marks = writableSelf.__marks;
+
+    if (marks !== null) {
+      updateTextMarks(writableSelf, marks, offset, delCount, handledTextLength);
+    }
+
+    writableSelf.__text = updatedText;
+    return writableSelf;
   }
 
   canInsertTextBefore() {
@@ -7590,6 +7982,7 @@ class TextNode extends LexicalNode {
     const format = self.getFormat();
     const style = self.getStyle();
     const detail = self.__detail;
+    const marks = self.__marks;
     let hasReplacedSelf = false;
 
     if (self.isSegmented()) {
@@ -7599,6 +7992,7 @@ class TextNode extends LexicalNode {
       writableNode.__format = format;
       writableNode.__style = style;
       writableNode.__detail = detail;
+      writableNode.__marks = marks;
       hasReplacedSelf = true;
     } else {
       // For the first part, update the existing node
@@ -7646,6 +8040,46 @@ class TextNode extends LexicalNode {
       textSize = nextTextSize;
       sibling.__parent = parentKey;
       splitNodes.push(sibling);
+    }
+
+    if (marks !== null) {
+      for (let i = 0; i < marks.length; i++) {
+        const {
+          id,
+          start,
+          end
+        } = marks[i];
+        let foundStart = false;
+        let foundEnd = false;
+        let partSize = 0;
+
+        for (let s = 0; s < partsLength; s++) {
+          const textNode = splitNodes[s];
+          const nextPartSize = partSize + parts[s].length;
+          const nextStart = !foundStart && start !== null && nextPartSize > start - (start === 0 ? 1 : 0) ? start - partSize : null;
+          const nextEnd = !foundEnd && end !== null && nextPartSize >= end ? end - partSize : null;
+
+          if (nextStart !== null || nextEnd !== null) {
+            if (nextStart !== null) {
+              foundStart = true;
+            }
+
+            if (nextEnd !== null) {
+              foundEnd = true;
+            }
+
+            textNode.setMark(id, nextStart, nextEnd);
+
+            if (foundStart && foundEnd) {
+              break;
+            }
+          } else {
+            textNode.deleteMark(id);
+          }
+
+          partSize = nextPartSize;
+        }
+      }
     } // Insert the nodes into the parent's children
 
 
@@ -7705,10 +8139,20 @@ class TextNode extends LexicalNode {
       }
     }
 
-    const newText = isBefore ? target.__text + text : text + target.__text;
+    const targetText = target.__text;
+    const targetTextLength = targetText.length;
+    const newText = isBefore ? targetText + text : text + targetText;
     this.setTextContent(newText);
+    const writableSelf = this.getWritable();
+
+    const marks = target.getLatest().__marks;
+
+    if (marks !== null) {
+      updateTextMarks(writableSelf, marks, isBefore ? targetTextLength : 0, 0, textLength);
+    }
+
     target.remove();
-    return this.getLatest();
+    return writableSelf;
   }
 
   isTextEntity() {
@@ -7982,7 +8426,6 @@ function createEditor(editorConfig) {
   const config = editorConfig || {};
   const namespace = config.namespace || createUID();
   const theme = config.theme || {};
-  const context = config.context || {};
   const parentEditor = config.parentEditor || null;
   const disableEvents = config.disableEvents || false;
   const editorState = createEmptyEditorState();
@@ -8004,8 +8447,6 @@ function createEditor(editorConfig) {
 
 
   const editor = new LexicalEditor(editorState, parentEditor, registeredNodes, {
-    // $FlowFixMe: we use our internal type to simpify the generics
-    context,
     disableEvents,
     namespace,
     theme
@@ -8364,7 +8805,7 @@ class LexicalEditor {
  *
  * 
  */
-const VERSION = '0.2.4';
+const VERSION = '0.2.5';
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -8455,6 +8896,7 @@ 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.DRAGEND_COMMAND = DRAGEND_COMMAND;
 exports.DRAGSTART_COMMAND = DRAGSTART_COMMAND;
 exports.DROP_COMMAND = DROP_COMMAND;
 exports.DecoratorNode = DecoratorNode;