lexical 0.25.1-nightly.20250228.0 → 0.26.1-nightly.20250303.0

package/Lexical.dev.js

@@ -8,7 +8,19 @@
 
 'use strict';
 
-var lexical = require('lexical');
+/**
+ * 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.
+ *
+ */
+
+// Do not require this module directly! Use normal `invariant` calls.
+
+function formatDevErrorMessage(message) {
+  throw new Error(message);
+}
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -459,14 +471,6 @@ function initMutationObserver(editor) {
   });
 }
 
-/**
- * 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 coerceToJSON(v) {
   return v;
 }
@@ -652,7 +656,7 @@ function $checkCollision(node, stateConfig, state) {
     const collision = state.sharedConfigMap.get(stateConfig.key);
     if (collision !== undefined && collision !== stateConfig) {
       {
-        throw Error(`$setState: State key collision ${JSON.stringify(stateConfig.key)} detected in ${node.constructor.name} node with type ${node.getType()} and key ${node.getKey()}. Only one StateConfig with a given key should be used on a node.`);
+        formatDevErrorMessage(`$setState: State key collision ${JSON.stringify(stateConfig.key)} detected in ${node.constructor.name} node with type ${node.getType()} and key ${node.getKey()}. Only one StateConfig with a given key should be used on a node.`);
       }
     }
   }
@@ -768,11 +772,11 @@ class NodeState {
     const computedSize = size !== undefined ? size : computeSize(sharedConfigMap, unknownState, knownState);
     {
       if (!(size === undefined || computedSize === size)) {
-        throw Error(`NodeState: size != computedSize (${String(size)} != ${String(computedSize)})`);
+        formatDevErrorMessage(`NodeState: size != computedSize (${String(size)} != ${String(computedSize)})`);
       }
       for (const stateConfig of knownState.keys()) {
         if (!sharedConfigMap.has(stateConfig.key)) {
-          throw Error(`NodeState: sharedConfigMap missing knownState key ${stateConfig.key}`);
+          formatDevErrorMessage(`NodeState: sharedConfigMap missing knownState key ${stateConfig.key}`);
         }
       }
     }
@@ -1141,14 +1145,6 @@ function $normalizePoint(point) {
   }
 }
 
-/**
- * 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.
- *
- */
-
 let subTreeTextContent = '';
 let subTreeDirectionedTextContent = '';
 let subTreeTextFormat = null;
@@ -1237,7 +1233,7 @@ function $createNode(key, slot) {
   const node = activeNextNodeMap.get(key);
   if (node === undefined) {
     {
-      throw Error(`createNode: node does not exist in nodeMap`);
+      formatDevErrorMessage(`createNode: node does not exist in nodeMap`);
     }
   }
   const dom = node.createDOM(activeEditorConfig, activeEditor$1);
@@ -1431,7 +1427,7 @@ function createChildrenArray(element, nodeMap) {
     const node = nodeMap.get(nodeKey);
     if (node === undefined) {
       {
-        throw Error(`createChildrenArray: node does not exist in nodeMap`);
+        formatDevErrorMessage(`createChildrenArray: node does not exist in nodeMap`);
       }
     }
     children.push(nodeKey);
@@ -1478,10 +1474,10 @@ function $reconcileChildren(prevElement, nextElement, slot) {
     const prevChildren = createChildrenArray(prevElement, activePrevNodeMap);
     const nextChildren = createChildrenArray(nextElement, activeNextNodeMap);
     if (!(prevChildren.length === prevChildrenSize)) {
-      throw Error(`$reconcileChildren: prevChildren.length !== prevChildrenSize`);
+      formatDevErrorMessage(`$reconcileChildren: prevChildren.length !== prevChildrenSize`);
     }
     if (!(nextChildren.length === nextChildrenSize)) {
-      throw Error(`$reconcileChildren: nextChildren.length !== nextChildrenSize`);
+      formatDevErrorMessage(`$reconcileChildren: nextChildren.length !== nextChildrenSize`);
     }
     if (prevChildrenSize === 0) {
       if (nextChildrenSize !== 0) {
@@ -1511,7 +1507,7 @@ function $reconcileNode(key, parentDOM) {
   let nextNode = activeNextNodeMap.get(key);
   if (prevNode === undefined || nextNode === undefined) {
     {
-      throw Error(`reconcileNode: prevNode or nextNode does not exist in nodeMap`);
+      formatDevErrorMessage(`reconcileNode: prevNode or nextNode does not exist in nodeMap`);
     }
   }
   const isDirty = treatAllNodesAsDirty || activeDirtyLeaves.has(key) || activeDirtyElements.has(key);
@@ -1552,7 +1548,7 @@ function $reconcileNode(key, parentDOM) {
     const replacementDOM = $createNode(key, null);
     if (parentDOM === null) {
       {
-        throw Error(`reconcileNode: parentDOM is null`);
+        formatDevErrorMessage(`reconcileNode: parentDOM is null`);
       }
     }
     parentDOM.replaceChild(replacementDOM, dom);
@@ -1747,7 +1743,7 @@ function getPrevElementByKeyOrThrow(key) {
   const element = activePrevKeyToDOMMap.get(key);
   if (element === undefined) {
     {
-      throw Error(`Reconciliation: could not find DOM element for node key ${key}`);
+      formatDevErrorMessage(`Reconciliation: could not find DOM element for node key ${key}`);
     }
   }
   return element;
@@ -1812,14 +1808,6 @@ const FOCUS_COMMAND = createCommand('FOCUS_COMMAND');
 const BLUR_COMMAND = createCommand('BLUR_COMMAND');
 const KEY_MODIFIER_COMMAND = createCommand('KEY_MODIFIER_COMMAND');
 
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
 const PASS_THROUGH_COMMAND = Object.freeze({});
 const ANDROID_COMPOSITION_LATENCY = 30;
 const rootElementEvents = [['keydown', onKeyDown], ['pointerdown', onPointerDown], ['compositionstart', onCompositionStart], ['compositionend', onCompositionEnd], ['input', onInput], ['click', onClick], ['cut', PASS_THROUGH_COMMAND], ['copy', PASS_THROUGH_COMMAND], ['dragstart', PASS_THROUGH_COMMAND], ['dragover', PASS_THROUGH_COMMAND], ['dragend', PASS_THROUGH_COMMAND], ['paste', PASS_THROUGH_COMMAND], ['focus', PASS_THROUGH_COMMAND], ['blur', PASS_THROUGH_COMMAND], ['drop', PASS_THROUGH_COMMAND]];
@@ -1837,6 +1825,7 @@ let isInsertLineBreak = false;
 let isFirefoxEndingComposition = false;
 let isSafariEndingComposition = false;
 let safariEndCompositionEventData = '';
+let postDeleteSelectionToRestore = null;
 let collapsedSelectionFormat = [0, '', 0, 'root', 0];
 
 // This function is used to determine if Lexical should attempt to override
@@ -1905,7 +1894,7 @@ function onSelectionChange(domSelection, editor, isActive) {
     // 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 (shouldSkipSelectionChange(anchorDOM, anchorOffset) && shouldSkipSelectionChange(focusDOM, focusOffset)) {
+    if (shouldSkipSelectionChange(anchorDOM, anchorOffset) && shouldSkipSelectionChange(focusDOM, focusOffset) && !postDeleteSelectionToRestore) {
       return;
     }
   }
@@ -1919,7 +1908,23 @@ function onSelectionChange(domSelection, editor, isActive) {
     if (!isSelectionWithinEditor(editor, anchorDOM, focusDOM)) {
       return;
     }
-    const selection = $getSelection();
+    let selection = $getSelection();
+
+    // Restore selection in the event of incorrect rightward shift after deletion
+    if (postDeleteSelectionToRestore && $isRangeSelection(selection) && selection.isCollapsed()) {
+      const curAnchor = selection.anchor;
+      const prevAnchor = postDeleteSelectionToRestore.anchor;
+      if (
+      // Rightward shift in same node
+      curAnchor.key === prevAnchor.key && curAnchor.offset === prevAnchor.offset + 1 ||
+      // Or rightward shift into sibling node
+      curAnchor.offset === 1 && prevAnchor.getNode().is(curAnchor.getNode().getPreviousSibling())) {
+        // Restore selection
+        selection = postDeleteSelectionToRestore.clone();
+        $setSelection(selection);
+      }
+    }
+    postDeleteSelectionToRestore = null;
 
     // Update the selection format
     if ($isRangeSelection(selection)) {
@@ -1944,12 +1949,12 @@ function onSelectionChange(domSelection, editor, isActive) {
         } else {
           if (anchor.type === 'text') {
             if (!$isTextNode(anchorNode)) {
-              throw Error(`Point.getNode() must return TextNode when type is text`);
+              formatDevErrorMessage(`Point.getNode() must return TextNode when type is text`);
             }
             $updateSelectionFormatStyleFromTextNode(selection, anchorNode);
           } else if (anchor.type === 'element' && !isRootTextContentEmpty) {
             if (!$isElementNode(anchorNode)) {
-              throw Error(`Point.getNode() must return ElementNode when type is element`);
+              formatDevErrorMessage(`Point.getNode() must return ElementNode when type is element`);
             }
             const lastNode = anchor.getNode();
             if (
@@ -2132,7 +2137,7 @@ function onBeforeInput(event, editor) {
             const anchorNode = selection.anchor.getNode();
             anchorNode.markDirty();
             if (!$isTextNode(anchorNode)) {
-              throw Error(`Anchor node must be a TextNode`);
+              formatDevErrorMessage(`Anchor node must be a TextNode`);
             }
             $updateSelectionFormatStyleFromTextNode(selection, anchorNode);
           }
@@ -2156,6 +2161,14 @@ function onBeforeInput(event, editor) {
           }
           if (!shouldLetBrowserHandleDelete) {
             dispatchCommand(editor, DELETE_CHARACTER_COMMAND, true);
+            // When deleting across paragraphs, Chrome on Android incorrectly shifts the selection rightwards
+            // We save the correct selection to restore later during handling of selectionchange event
+            const selectionAfterDelete = $getSelection();
+            if (IS_ANDROID_CHROME && $isRangeSelection(selectionAfterDelete) && selectionAfterDelete.isCollapsed()) {
+              postDeleteSelectionToRestore = selectionAfterDelete;
+              // Cleanup in case selectionchange does not fire
+              setTimeout(() => postDeleteSelectionToRestore = null);
+            }
           }
         }
         return;
@@ -2729,12 +2742,12 @@ function removeRootElementEvents(rootElement) {
   const doc = rootElement.ownerDocument;
   const documentRootElementsCount = rootElementsRegistered.get(doc);
   if (!(documentRootElementsCount !== undefined)) {
-    throw Error(`Root element not registered`);
+    formatDevErrorMessage(`Root element not registered`);
   } // We only want to have a single global selectionchange event handler, shared
   // between all editor instances.
   const newCount = documentRootElementsCount - 1;
   if (!(newCount >= 0)) {
-    throw Error(`Root element count less than 0`);
+    formatDevErrorMessage(`Root element count less than 0`);
   }
   rootElementsRegistered.set(doc, newCount);
   if (newCount === 0) {
@@ -2747,7 +2760,7 @@ function removeRootElementEvents(rootElement) {
     rootElement.__lexicalEditor = null;
   } else if (editor) {
     {
-      throw Error(`Attempted to remove event handlers from a node that does not belong to this build of Lexical`);
+      formatDevErrorMessage(`Attempted to remove event handlers from a node that does not belong to this build of Lexical`);
     }
   }
   const removeHandles = getRootElementRemoveHandles(rootElement);
@@ -2779,15 +2792,6 @@ function markCollapsedSelectionFormat(format, style, offset, key, timeStamp) {
   collapsedSelectionFormat = [format, style, offset, key, timeStamp];
 }
 
-/**
- * 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.
- *
- */
-
-
 /**
  * The base type for all serialized nodes
  */
@@ -2865,7 +2869,7 @@ class LexicalNode {
    */
   static getType() {
     {
-      throw Error(`LexicalNode: Node ${this.name} does not implement .getType().`);
+      formatDevErrorMessage(`LexicalNode: Node ${this.name} does not implement .getType().`);
     }
   }
 
@@ -2877,7 +2881,7 @@ class LexicalNode {
    */
   static clone(_data) {
     {
-      throw Error(`LexicalNode: Node ${this.name} does not implement .clone().`);
+      formatDevErrorMessage(`LexicalNode: Node ${this.name} does not implement .clone().`);
     }
   }
 
@@ -2969,7 +2973,7 @@ class LexicalNode {
   }
   isInline() {
     {
-      throw Error(`LexicalNode: Node ${this.constructor.name} does not implement .isInline().`);
+      formatDevErrorMessage(`LexicalNode: Node ${this.constructor.name} does not implement .isInline().`);
     }
   }
 
@@ -3073,7 +3077,7 @@ class LexicalNode {
     const parent = this.getParent();
     if (parent === null) {
       {
-        throw Error(`Expected node ${this.__key} to have a parent.`);
+        formatDevErrorMessage(`Expected node ${this.__key} to have a parent.`);
       }
     }
     return parent;
@@ -3090,7 +3094,7 @@ class LexicalNode {
       const parent = node.getParent();
       if ($isRootOrShadowRoot(parent)) {
         if (!($isElementNode(node) || node === this && $isDecoratorNode(node))) {
-          throw Error(`Children of root nodes must be elements or decorators`);
+          formatDevErrorMessage(`Children of root nodes must be elements or decorators`);
         }
         return node;
       }
@@ -3108,7 +3112,7 @@ class LexicalNode {
     const parent = this.getTopLevelElement();
     if (parent === null) {
       {
-        throw Error(`Expected node ${this.__key} to have a top parent element.`);
+        formatDevErrorMessage(`Expected node ${this.__key} to have a top parent element.`);
       }
     }
     return parent;
@@ -3252,7 +3256,7 @@ class LexicalNode {
       return $getCommonAncestorResultBranchOrder(compare) === -1;
     }
     if (!(compare.type === 'same' || compare.type === 'ancestor')) {
-      throw Error(`LexicalNode.isBefore: exhaustiveness check`);
+      formatDevErrorMessage(`LexicalNode.isBefore: exhaustiveness check`);
     }
     return false;
   }
@@ -3313,7 +3317,7 @@ class LexicalNode {
       do {
         if (ancestor === null) {
           {
-            throw Error(`getNodesBetween: ancestor is null`);
+            formatDevErrorMessage(`getNodesBetween: ancestor is null`);
           }
         }
         parentSibling = isBefore ? ancestor.getNextSibling() : ancestor.getPreviousSibling();
@@ -3353,7 +3357,7 @@ class LexicalNode {
     const latest = $getNodeByKey(this.__key);
     if (latest === null) {
       {
-        throw Error(`Lexical node does not exist in active editor state. Avoid using the same node references between nested closures from editorState.read/editor.update.`);
+        formatDevErrorMessage(`Lexical node does not exist in active editor state. Avoid using the same node references between nested closures from editorState.read/editor.update.`);
       }
     }
     return latest;
@@ -3425,7 +3429,7 @@ class LexicalNode {
    * */
   createDOM(_config, _editor) {
     {
-      throw Error(`createDOM: base method not extended`);
+      formatDevErrorMessage(`createDOM: base method not extended`);
     }
   }
 
@@ -3441,7 +3445,7 @@ class LexicalNode {
    * */
   updateDOM(_prevNode, _dom, _config) {
     {
-      throw Error(`updateDOM: base method not extended`);
+      formatDevErrorMessage(`updateDOM: base method not extended`);
     }
   }
 
@@ -3486,7 +3490,7 @@ class LexicalNode {
    * */
   static importJSON(_serializedNode) {
     {
-      throw Error(`LexicalNode: Node ${this.name} does not implement .importJSON().`);
+      formatDevErrorMessage(`LexicalNode: Node ${this.name} does not implement .importJSON().`);
     }
   }
 
@@ -3519,7 +3523,7 @@ class LexicalNode {
    * ```
    **/
   updateFromJSON(serializedNode) {
-    return $updateStateFromJSON(this, serializedNode[lexical.NODE_STATE_KEY]);
+    return $updateStateFromJSON(this, serializedNode[NODE_STATE_KEY]);
   }
 
   /**
@@ -3594,7 +3598,7 @@ class LexicalNode {
     writableParent.__size = size;
     if (includeChildren) {
       if (!($isElementNode(this) && $isElementNode(writableReplaceWith))) {
-        throw Error(`includeChildren should only be true for ElementNodes`);
+        formatDevErrorMessage(`includeChildren should only be true for ElementNodes`);
       }
       this.getChildren().forEach(child => {
         writableReplaceWith.append(child);
@@ -3804,13 +3808,13 @@ function errorOnTypeKlassMismatch(type, klass) {
   // Common error - split in its own invariant
   if (registeredNode === undefined) {
     {
-      throw Error(`Create node: Attempted to create node ${klass.name} that was not configured to be used on the editor.`);
+      formatDevErrorMessage(`Create node: Attempted to create node ${klass.name} that was not configured to be used on the editor.`);
     }
   }
   const editorKlass = registeredNode.klass;
   if (editorKlass !== klass) {
     {
-      throw Error(`Create node: Type ${type} in node ${klass.name} does not match registered node ${editorKlass.name} with the same type`);
+      formatDevErrorMessage(`Create node: Type ${type} in node ${klass.name} does not match registered node ${editorKlass.name} with the same type`);
     }
   }
 }
@@ -3829,7 +3833,7 @@ function insertRangeAfter(node, firstToInsert, lastToInsert) {
   while (current !== lastToInsert2) {
     if (!current.getNextSibling()) {
       {
-        throw Error(`insertRangeAfter: lastToInsert must be a later sibling of firstToInsert`);
+        formatDevErrorMessage(`insertRangeAfter: lastToInsert must be a later sibling of firstToInsert`);
       }
     }
     current = current.getNextSibling();
@@ -3869,6 +3873,9 @@ class LineBreakNode extends LexicalNode {
   updateDOM() {
     return false;
   }
+  isInline() {
+    return true;
+  }
   static importDOM() {
     return {
       br: node => {
@@ -3931,14 +3938,6 @@ function isWhitespaceDomTextNode(node) {
   return isDOMTextNode(node) && /^( |\t|\r?\n)+$/.test(node.textContent || '');
 }
 
-/**
- * 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 getElementOuterTag(node, format) {
   if (format & IS_CODE) {
     return 'code';
@@ -4246,6 +4245,13 @@ class TextNode extends LexicalNode {
     return true;
   }
 
+  /**
+   * @returns true if the text node is inline, false otherwise.
+   */
+  isInline() {
+    return true;
+  }
+
   // View
 
   createDOM(config, editor) {
@@ -4288,7 +4294,7 @@ class TextNode extends LexicalNode {
       const prevInnerDOM = dom.firstChild;
       if (prevInnerDOM == null) {
         {
-          throw Error(`updateDOM: prevInnerDOM is null or undefined`);
+          formatDevErrorMessage(`updateDOM: prevInnerDOM is null or undefined`);
         }
       }
       const nextInnerDOM = document.createElement(nextInnerTag);
@@ -4302,7 +4308,7 @@ class TextNode extends LexicalNode {
         innerDOM = dom.firstChild;
         if (innerDOM == null) {
           {
-            throw Error(`updateDOM: innerDOM is null or undefined`);
+            formatDevErrorMessage(`updateDOM: innerDOM is null or undefined`);
           }
         }
       }
@@ -4388,7 +4394,7 @@ class TextNode extends LexicalNode {
       element
     } = super.exportDOM(editor);
     if (!isHTMLElement(element)) {
-      throw Error(`Expected TextNode createDOM to always return a HTMLElement`);
+      formatDevErrorMessage(`Expected TextNode createDOM to always return a HTMLElement`);
     }
     element.style.whiteSpace = 'pre-wrap';
     // This is the only way to properly add support for most clients,
@@ -4783,7 +4789,7 @@ class TextNode extends LexicalNode {
     const isBefore = target === this.getPreviousSibling();
     if (!isBefore && target !== this.getNextSibling()) {
       {
-        throw Error(`mergeWithSibling: sibling must be a previous or next sibling`);
+        formatDevErrorMessage(`mergeWithSibling: sibling must be a previous or next sibling`);
       }
     }
     const key = this.__key;
@@ -4871,7 +4877,7 @@ function $convertTextDOMNode(domNode) {
   const domNode_ = domNode;
   const parentDom = domNode.parentElement;
   if (!(parentDom !== null)) {
-    throw Error(`Expected parentElement of Text not to be null`);
+    formatDevErrorMessage(`Expected parentElement of Text not to be null`);
   }
   let textContent = domNode_.textContent || '';
   // No collapse and preserve segment break for pre, pre-wrap and pre-line
@@ -5044,14 +5050,6 @@ function applyTextFormatFromStyle(style, shouldApply) {
   };
 }
 
-/**
- * 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.
- *
- */
-
 /** @noInheritDoc */
 class TabNode extends TextNode {
   static getType() {
@@ -5081,19 +5079,19 @@ class TabNode extends TextNode {
   }
   setTextContent(text) {
     if (!(text === '\t' || text === '')) {
-      throw Error(`TabNode does not support setTextContent`);
+      formatDevErrorMessage(`TabNode does not support setTextContent`);
     }
     return super.setTextContent(text);
   }
   setDetail(detail) {
     if (!(detail === IS_UNMERGEABLE)) {
-      throw Error(`TabNode does not support setDetail`);
+      formatDevErrorMessage(`TabNode does not support setDetail`);
     }
     return this;
   }
   setMode(type) {
     if (!(type === 'normal')) {
-      throw Error(`TabNode does not support setMode`);
+      formatDevErrorMessage(`TabNode does not support setMode`);
     }
     return this;
   }
@@ -5111,14 +5109,6 @@ function $isTabNode(node) {
   return node instanceof TabNode;
 }
 
-/**
- * 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.
- *
- */
-
 class Point {
   constructor(key, offset, type) {
     {
@@ -5138,29 +5128,19 @@ class Point {
     return this.key === point.key && this.offset === point.offset && this.type === point.type;
   }
   isBefore(b) {
-    let aNode = this.getNode();
-    let bNode = b.getNode();
-    const aOffset = this.offset;
-    const bOffset = b.offset;
-    if ($isElementNode(aNode)) {
-      const aNodeDescendant = aNode.getDescendantByIndex(aOffset);
-      aNode = aNodeDescendant != null ? aNodeDescendant : aNode;
-    }
-    if ($isElementNode(bNode)) {
-      const bNodeDescendant = bNode.getDescendantByIndex(bOffset);
-      bNode = bNodeDescendant != null ? bNodeDescendant : bNode;
+    if (this.key === b.key) {
+      return this.offset < b.offset;
     }
-    if (aNode === bNode) {
-      return aOffset < bOffset;
-    }
-    return aNode.isBefore(bNode);
+    const aCaret = $normalizeCaret($caretFromPoint(this, 'next'));
+    const bCaret = $normalizeCaret($caretFromPoint(b, 'next'));
+    return $comparePointCaretNext(aCaret, bCaret) < 0;
   }
   getNode() {
     const key = this.key;
     const node = $getNodeByKey(key);
     if (node === null) {
       {
-        throw Error(`Point.getNode: node not found`);
+        formatDevErrorMessage(`Point.getNode: node not found`);
       }
     }
     return node;
@@ -5177,7 +5157,7 @@ class Point {
     {
       const node = $getNodeByKey(key);
       if (!(type === 'text' ? $isTextNode(node) : $isElementNode(node))) {
-        throw Error(`PointType.set: node with key ${key} is ${node ? node.__type : '[not found]'} and can not be used for a ${type} point`);
+        formatDevErrorMessage(`PointType.set: node with key ${key} is ${node ? node.__type : '[not found]'} and can not be used for a ${type} point`);
       }
     }
     if (!isCurrentlyReadOnlyMode()) {
@@ -5420,7 +5400,7 @@ class RangeSelection {
     {
       if (this.isCollapsed() && nodes.length > 1) {
         {
-          throw Error(`RangeSelection.getNodes() returned ${String(nodes.length)} > 1 nodes in a collapsed selection`);
+          formatDevErrorMessage(`RangeSelection.getNodes() returned ${String(nodes.length)} > 1 nodes in a collapsed selection`);
         }
       }
     }
@@ -5659,7 +5639,7 @@ class RangeSelection {
     let firstNode = selectedNodes[0];
     if (!$isTextNode(firstNode)) {
       {
-        throw Error(`insertText: first node is not a text node`);
+        formatDevErrorMessage(`insertText: first node is not a text node`);
       }
     }
     const firstNodeText = firstNode.getTextContent();
@@ -6054,7 +6034,7 @@ class RangeSelection {
       this.insertParagraph();
       const selection = $getSelection();
       if (!$isRangeSelection(selection)) {
-        throw Error(`Expected RangeSelection after insertParagraph`);
+        formatDevErrorMessage(`Expected RangeSelection after insertParagraph`);
       }
       return selection.insertNodes(nodes);
     }
@@ -6079,7 +6059,7 @@ class RangeSelection {
     const notInline = node => ($isElementNode(node) || $isDecoratorNode(node)) && !node.isInline();
     if (!nodes.some(notInline)) {
       if (!$isElementNode(firstBlock)) {
-        throw Error(`Expected node ${firstNode.constructor.name} of type ${firstNode.getType()} to have a block ElementNode ancestor`);
+        formatDevErrorMessage(`Expected node ${firstNode.constructor.name} of type ${firstNode.getType()} to have a block ElementNode ancestor`);
       }
       const index = $removeTextAndSplitBlock(this);
       firstBlock.splice(index, 0, nodes);
@@ -6098,14 +6078,14 @@ class RangeSelection {
     let firstToInsert = blocks[0];
     if (isMergeable(firstToInsert)) {
       if (!$isElementNode(firstBlock)) {
-        throw Error(`Expected node ${firstNode.constructor.name} of type ${firstNode.getType()} to have a block ElementNode ancestor`);
+        formatDevErrorMessage(`Expected node ${firstNode.constructor.name} of type ${firstNode.getType()} to have a block ElementNode ancestor`);
       }
       firstBlock.append(...firstToInsert.getChildren());
       firstToInsert = blocks[1];
     }
     if (firstToInsert) {
       if (!(firstBlock !== null)) {
-        throw Error(`Expected node ${firstNode.constructor.name} of type ${firstNode.getType()} to have a block ancestor`);
+        formatDevErrorMessage(`Expected node ${firstNode.constructor.name} of type ${firstNode.getType()} to have a block ancestor`);
       }
       insertRangeAfter(firstBlock, firstToInsert);
     }
@@ -6141,7 +6121,7 @@ class RangeSelection {
     const index = $removeTextAndSplitBlock(this);
     const block = $getAncestor(this.anchor.getNode(), INTERNAL_$isBlock);
     if (!$isElementNode(block)) {
-      throw Error(`Expected ancestor to be a block ElementNode`);
+      formatDevErrorMessage(`Expected ancestor to be a block ElementNode`);
     }
     const firstToAppend = block.getChildAtIndex(index);
     const nodesToInsert = firstToAppend ? [firstToAppend, ...firstToAppend.getNextSiblings()] : [];
@@ -6231,51 +6211,10 @@ class RangeSelection {
    * @param granularity the granularity at which to apply the modification
    */
   modify(alter, isBackward, granularity) {
-    const focus = this.focus;
-    const anchor = this.anchor;
-    const collapse = alter === 'move';
-
-    // Handle the selection movement around decorators.
-    const possibleNode = $getAdjacentNode(focus, isBackward);
-    if ($isDecoratorNode(possibleNode) && !possibleNode.isIsolated()) {
-      // Make it possible to move selection from range selection to
-      // node selection on the node.
-      if (collapse && possibleNode.isKeyboardSelectable()) {
-        const nodeSelection = $createNodeSelection();
-        nodeSelection.add(possibleNode.__key);
-        $setSelection(nodeSelection);
-        return;
-      }
-      const sibling = isBackward ? possibleNode.getPreviousSibling() : possibleNode.getNextSibling();
-      if (!$isTextNode(sibling)) {
-        const parent = possibleNode.getParentOrThrow();
-        let offset;
-        let elementKey;
-        if ($isElementNode(sibling)) {
-          elementKey = sibling.__key;
-          offset = isBackward ? sibling.getChildrenSize() : 0;
-        } else {
-          offset = possibleNode.getIndexWithinParent();
-          elementKey = parent.__key;
-          if (!isBackward) {
-            offset++;
-          }
-        }
-        focus.set(elementKey, offset, 'element');
-        if (collapse) {
-          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;
-      }
+    if ($modifySelectionAroundDecoratorsAndBlocks(this, alter, isBackward, granularity)) {
+      return;
     }
+    const collapse = alter === 'move';
     const editor = getActiveEditor();
     const domSelection = getDOMSelection(getWindow(editor));
     if (!domSelection) {
@@ -6283,12 +6222,26 @@ class RangeSelection {
     }
     const blockCursorElement = editor._blockCursorElement;
     const rootElement = editor._rootElement;
+    const focusNode = this.focus.getNode();
     // Remove the block cursor element if it exists. This will ensure selection
     // works as intended. If we leave it in the DOM all sorts of strange bugs
     // occur. :/
-    if (rootElement !== null && blockCursorElement !== null && $isElementNode(possibleNode) && !possibleNode.isInline() && !possibleNode.canBeEmpty()) {
+    if (rootElement !== null && blockCursorElement !== null && $isElementNode(focusNode) && !focusNode.isInline() && !focusNode.canBeEmpty()) {
       removeDOMBlockCursorElement(blockCursorElement, editor, rootElement);
     }
+    if (this.dirty) {
+      let nextAnchorDOM = getElementByKeyOrThrow(editor, this.anchor.key);
+      let nextFocusDOM = getElementByKeyOrThrow(editor, this.focus.key);
+      if (this.anchor.type === 'text') {
+        nextAnchorDOM = getDOMTextNode(nextAnchorDOM);
+      }
+      if (this.focus.type === 'text') {
+        nextFocusDOM = getDOMTextNode(nextFocusDOM);
+      }
+      if (nextAnchorDOM && nextFocusDOM) {
+        setDOMSelectionBaseAndExtent(domSelection, nextAnchorDOM, this.anchor.offset, nextFocusDOM, this.focus.offset);
+      }
+    }
     // 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
@@ -6345,6 +6298,9 @@ class RangeSelection {
         }
       }
     }
+    if (granularity === 'lineboundary') {
+      $modifySelectionAroundDecoratorsAndBlocks(this, alter, isBackward, granularity, 'decorators');
+    }
   }
   /**
    * Helper for handling forward character and word deletion that prevents element nodes
@@ -6385,7 +6341,6 @@ class RangeSelection {
       const initialCaret = $caretFromPoint(anchor, direction);
       const initialRange = $extendCaretToRange(initialCaret);
       if (initialRange.getTextSlices().every(slice => slice === null || slice.distance === 0)) {
-        // debugger;
         // There's no text in the direction of the deletion so we can explore our options
         let state = {
           type: 'initial'
@@ -6501,30 +6456,16 @@ class RangeSelection {
    */
   deleteLine(isBackward) {
     if (this.isCollapsed()) {
-      // Since `domSelection.modify('extend', ..., 'lineboundary')` works well for text selections
-      // but doesn't properly handle selections which end on elements, a space character is added
-      // for such selections transforming their anchor's type to 'text'
-      const anchorIsElement = this.anchor.type === 'element';
-      if (anchorIsElement) {
-        this.insertText(' ');
-      }
       this.modify('extend', isBackward, 'lineboundary');
-      const useDeleteCharacter = this.isCollapsed() && this.anchor.offset === 0;
-      // Adjusts selection to include an extra character added for element anchors to remove it
-      if (anchorIsElement) {
-        const startPoint = isBackward ? this.anchor : this.focus;
-        startPoint.set(startPoint.key, startPoint.offset + 1, startPoint.type);
-      }
-      // If the selection starts at the beginning of a text node (offset 0),
+    }
+    if (this.isCollapsed()) {
+      // If the selection was already collapsed at the lineboundary,
       // use the deleteCharacter operation to handle all of the logic associated
       // with navigating through the parent element
-      if (useDeleteCharacter) {
-        // Remove the inserted space, if added above
-        this.removeText();
-        return this.deleteCharacter(isBackward);
-      }
+      this.deleteCharacter(isBackward);
+    } else {
+      this.removeText();
     }
-    this.removeText();
   }
 
   /**
@@ -6702,7 +6643,7 @@ function $updateCaretSelectionForUnicodeCharacter(selection, isBackward) {
 function shouldDeleteExactlyOneCodeUnit(text) {
   {
     if (!(text.length > 1)) {
-      throw Error(`shouldDeleteExactlyOneCodeUnit: expecting to be called only with sequences of two or more code units`);
+      formatDevErrorMessage(`shouldDeleteExactlyOneCodeUnit: expecting to be called only with sequences of two or more code units`);
     }
   }
   return !(doesContainSurrogatePair(text) || doesContainEmoji(text));
@@ -6824,13 +6765,13 @@ function $internalResolveSelectionPoint(dom, offset, lastPoint, editor) {
       if ($isElementNode(resolvedElement)) {
         const elementDOM = editor.getElementByKey(resolvedElement.getKey());
         if (!(elementDOM !== null)) {
-          throw Error(`$internalResolveSelectionPoint: node in DOM but not keyToDOMMap`);
+          formatDevErrorMessage(`$internalResolveSelectionPoint: node in DOM but not keyToDOMMap`);
         }
         const slot = resolvedElement.getDOMSlot(elementDOM);
         [resolvedElement, resolvedOffset] = slot.resolveChildIndex(resolvedElement, elementDOM, dom, offset);
         // This is just a typescript workaround, it is true but lost due to mutability
         if (!$isElementNode(resolvedElement)) {
-          throw Error(`$internalResolveSelectionPoint: resolvedElement is not an ElementNode`);
+          formatDevErrorMessage(`$internalResolveSelectionPoint: resolvedElement is not an ElementNode`);
         }
         if (moveSelectionToEnd && resolvedOffset >= resolvedElement.getChildrenSize()) {
           resolvedOffset = Math.max(0, resolvedElement.getChildrenSize() - 1);
@@ -6852,7 +6793,7 @@ function $internalResolveSelectionPoint(dom, offset, lastPoint, editor) {
           resolvedOffset = getTextNodeOffset(child, moveSelectionToEnd);
         } else if (child !== resolvedElement && moveSelectionToEnd && !hasBlockCursor) {
           if (!$isElementNode(resolvedElement)) {
-            throw Error(`invariant`);
+            formatDevErrorMessage(`invariant`);
           }
           resolvedOffset = Math.min(resolvedElement.getChildrenSize(), resolvedOffset + 1);
         }
@@ -7048,23 +6989,23 @@ function $internalCreateRangeSelection(lastSelection, domSelection, editor, even
 function $validatePoint(editor, name, point) {
   const node = $getNodeByKey(point.key);
   if (!(node !== undefined)) {
-    throw Error(`$validatePoint: ${name} key ${point.key} not found in current editorState`);
+    formatDevErrorMessage(`$validatePoint: ${name} key ${point.key} not found in current editorState`);
   }
   if (point.type === 'text') {
     if (!$isTextNode(node)) {
-      throw Error(`$validatePoint: ${name} key ${point.key} is not a TextNode`);
+      formatDevErrorMessage(`$validatePoint: ${name} key ${point.key} is not a TextNode`);
     }
     const size = node.getTextContentSize();
     if (!(point.offset <= size)) {
-      throw Error(`$validatePoint: ${name} point.offset > node.getTextContentSize() (${String(point.offset)} > ${String(size)})`);
+      formatDevErrorMessage(`$validatePoint: ${name} point.offset > node.getTextContentSize() (${String(point.offset)} > ${String(size)})`);
     }
   } else {
     if (!$isElementNode(node)) {
-      throw Error(`$validatePoint: ${name} key ${point.key} is not an ElementNode`);
+      formatDevErrorMessage(`$validatePoint: ${name} key ${point.key} is not an ElementNode`);
     }
     const size = node.getChildrenSize();
     if (!(point.offset <= size)) {
-      throw Error(`$validatePoint: ${name} point.offset > node.getChildrenSize() (${String(point.offset)} > ${String(size)})`);
+      formatDevErrorMessage(`$validatePoint: ${name} point.offset > node.getChildrenSize() (${String(point.offset)} > ${String(size)})`);
     }
   }
 }
@@ -7228,6 +7169,20 @@ function adjustPointOffsetForMergedSibling(point, isBefore, key, target, textLen
     point.set(point.key, point.offset - 1, 'element');
   }
 }
+function setDOMSelectionBaseAndExtent(domSelection, nextAnchorDOM, nextAnchorOffset, nextFocusDOM, nextFocusOffset) {
+  // Apply the updated selection to the DOM. Note: this will trigger
+  // a "selectionchange" event, although it will be asynchronous.
+  try {
+    domSelection.setBaseAndExtent(nextAnchorDOM, nextAnchorOffset, nextFocusDOM, nextFocusOffset);
+  } catch (error) {
+    // If we encounter an error, continue. This can sometimes
+    // occur with FF and there's no good reason as to why it
+    // should happen.
+    {
+      console.warn(error);
+    }
+  }
+}
 function updateDOMSelection(prevSelection, nextSelection, editor, domSelection, tags, rootElement, nodeCount) {
   const anchorDOMNode = domSelection.anchorNode;
   const focusDOMNode = domSelection.focusNode;
@@ -7304,16 +7259,7 @@ function updateDOMSelection(prevSelection, nextSelection, editor, domSelection,
 
   // Apply the updated selection to the DOM. Note: this will trigger
   // a "selectionchange" event, although it will be asynchronous.
-  try {
-    domSelection.setBaseAndExtent(nextAnchorNode, nextAnchorOffset, nextFocusNode, nextFocusOffset);
-  } catch (error) {
-    // If we encounter an error, continue. This can sometimes
-    // occur with FF and there's no good reason as to why it
-    // should happen.
-    {
-      console.warn(error);
-    }
-  }
+  setDOMSelectionBaseAndExtent(domSelection, nextAnchorNode, nextAnchorOffset, nextFocusNode, nextFocusOffset);
   if (!tags.has('skip-scroll-into-view') && nextSelection.isCollapsed() && rootElement !== null && rootElement === document.activeElement) {
     const selectionTarget = $isRangeSelection(nextSelection) && nextSelection.anchor.type === 'element' ? nextAnchorNode.childNodes[nextAnchorOffset] || null : domSelection.rangeCount > 0 ? domSelection.getRangeAt(0) : null;
     if (selectionTarget !== null) {
@@ -7356,7 +7302,7 @@ function $removeTextAndSplitBlock(selection) {
     selection_ = newSelection;
   }
   if (!$isRangeSelection(selection_)) {
-    throw Error(`Unexpected dirty selection to be null`);
+    formatDevErrorMessage(`Unexpected dirty selection to be null`);
   }
   const anchor = selection_.anchor;
   let node = anchor.getNode();
@@ -7501,12 +7447,74 @@ range) {
 }
 
 /**
- * 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.
+ * @internal
  *
+ * Modify the focus of the focus around possible decorators and blocks and return true
+ * if the movement is done.
  */
+function $modifySelectionAroundDecoratorsAndBlocks(selection, alter, isBackward, granularity, mode = 'decorators-and-blocks') {
+  if (alter === 'move' && granularity === 'character' && !selection.isCollapsed()) {
+    // moving left or right when the selection isn't collapsed will
+    // just set the anchor to the focus or vice versa depending on
+    // direction
+    const [src, dst] = isBackward === selection.isBackward() ? [selection.focus, selection.anchor] : [selection.anchor, selection.focus];
+    dst.set(src.key, src.offset, src.type);
+    return true;
+  }
+  const initialFocus = $caretFromPoint(selection.focus, isBackward ? 'previous' : 'next');
+  const isLineBoundary = granularity === 'lineboundary';
+  const collapse = alter === 'move';
+  let focus = initialFocus;
+  let checkForBlock = mode === 'decorators-and-blocks';
+  if (!$isExtendableTextPointCaret(focus)) {
+    for (const siblingCaret of focus) {
+      checkForBlock = false;
+      const {
+        origin
+      } = siblingCaret;
+      if ($isDecoratorNode(origin) && !origin.isIsolated()) {
+        focus = siblingCaret;
+        if (isLineBoundary && origin.isInline()) {
+          continue;
+        }
+      }
+      break;
+    }
+    if (checkForBlock) {
+      for (const nextCaret of $extendCaretToRange(initialFocus).iterNodeCarets(alter === 'extend' ? 'shadowRoot' : 'root')) {
+        if ($isChildCaret(nextCaret)) {
+          if (!nextCaret.origin.isInline()) {
+            focus = nextCaret;
+          }
+        } else if ($isElementNode(nextCaret.origin)) {
+          continue;
+        } else if ($isDecoratorNode(nextCaret.origin) && !nextCaret.origin.isInline()) {
+          focus = nextCaret;
+        }
+        break;
+      }
+    }
+  }
+  if (focus === initialFocus) {
+    return false;
+  }
+  // After this point checkForBlock is true if and only if we moved to a
+  // different block, so we should stop regardless of the granularity
+  if (collapse && !isLineBoundary && $isDecoratorNode(focus.origin) && focus.origin.isKeyboardSelectable()) {
+    // Make it possible to move selection from range selection to
+    // node selection on the node.
+    const nodeSelection = $createNodeSelection();
+    nodeSelection.add(focus.origin.getKey());
+    $setSelection(nodeSelection);
+    return true;
+  }
+  focus = $normalizeCaret(focus);
+  if (collapse) {
+    $setPointFromCaret(selection.anchor, focus);
+  }
+  $setPointFromCaret(selection.focus, focus);
+  return checkForBlock || !isLineBoundary;
+}
 
 let activeEditorState = null;
 let activeEditor = null;
@@ -7524,21 +7532,21 @@ function isCurrentlyReadOnlyMode() {
 function errorOnReadOnly() {
   if (isReadOnlyMode) {
     {
-      throw Error(`Cannot use method in read-only mode.`);
+      formatDevErrorMessage(`Cannot use method in read-only mode.`);
     }
   }
 }
 function errorOnInfiniteTransforms() {
   if (infiniteTransformCount > 99) {
     {
-      throw Error(`One or more transforms are endlessly triggering additional transforms. May have encountered infinite recursion caused by transforms that have their preconditions too lose and/or conflict with each other.`);
+      formatDevErrorMessage(`One or more transforms are endlessly triggering additional transforms. May have encountered infinite recursion caused by transforms that have their preconditions too lose and/or conflict with each other.`);
     }
   }
 }
 function getActiveEditorState() {
   if (activeEditorState === null) {
     {
-      throw Error(`Unable to find an active editor state. State helpers or node methods can only be used synchronously during the callback of editor.update(), editor.read(), or editorState.read().${collectBuildInformation()}`);
+      formatDevErrorMessage(`Unable to find an active editor state. State helpers or node methods can only be used synchronously during the callback of editor.update(), editor.read(), or editorState.read().${collectBuildInformation()}`);
     }
   }
   return activeEditorState;
@@ -7546,7 +7554,7 @@ function getActiveEditorState() {
 function getActiveEditor() {
   if (activeEditor === null) {
     {
-      throw Error(`Unable to find an active editor. This method can only be used synchronously during the callback of editor.update() or editor.read().${collectBuildInformation()}`);
+      formatDevErrorMessage(`Unable to find an active editor. This method can only be used synchronously during the callback of editor.update() or editor.read().${collectBuildInformation()}`);
     }
   }
   return activeEditor;
@@ -7705,13 +7713,13 @@ function $parseSerializedNodeImpl(serializedNode, registeredNodes) {
   const registeredNode = registeredNodes.get(type);
   if (registeredNode === undefined) {
     {
-      throw Error(`parseEditorState: type "${type}" + not found`);
+      formatDevErrorMessage(`parseEditorState: type "${type}" + not found`);
     }
   }
   const nodeClass = registeredNode.klass;
   if (serializedNode.type !== nodeClass.getType()) {
     {
-      throw Error(`LexicalNode: Node ${nodeClass.name} does not implement .importJSON().`);
+      formatDevErrorMessage(`LexicalNode: Node ${nodeClass.name} does not implement .importJSON().`);
     }
   }
   const node = nodeClass.importJSON(serializedNode);
@@ -8067,7 +8075,7 @@ function processNestedUpdates(editor, initialSkipTransforms) {
         if (options.discrete) {
           const pendingEditorState = editor._pendingEditorState;
           if (!(pendingEditorState !== null)) {
-            throw Error(`Unexpected empty pending editor state on discrete nested update`);
+            formatDevErrorMessage(`Unexpected empty pending editor state on discrete nested update`);
           }
           pendingEditorState._flushSync = true;
         }
@@ -8146,7 +8154,7 @@ function $beginUpdate(editor, updateFn, options) {
       const focusKey = pendingSelection.focus.key;
       if (pendingNodeMap.get(anchorKey) === undefined || pendingNodeMap.get(focusKey) === undefined) {
         {
-          throw Error(`updateEditor: selection has been lost because the previously selected nodes have been removed and selection wasn't moved to another node. Ensure selection changes after removing/replacing a selected node.`);
+          formatDevErrorMessage(`updateEditor: selection has been lost because the previously selected nodes have been removed and selection wasn't moved to another node. Ensure selection changes after removing/replacing a selected node.`);
         }
       }
     } else if ($isNodeSelection(pendingSelection)) {
@@ -8218,15 +8226,6 @@ function updateEditor(editor, updateFn, options) {
   }
 }
 
-/**
- * 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.
- *
- */
-
-
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 
 /**
@@ -8266,7 +8265,7 @@ class ElementDOMSlot {
   insertChild(dom) {
     const before = this.before || this.getManagedLineBreak();
     if (!(before === null || before.parentElement === this.element)) {
-      throw Error(`ElementDOMSlot.insertChild: before is not in element`);
+      formatDevErrorMessage(`ElementDOMSlot.insertChild: before is not in element`);
     }
     this.element.insertBefore(dom, before);
     return this;
@@ -8276,7 +8275,7 @@ class ElementDOMSlot {
    */
   removeChild(dom) {
     if (!(dom.parentElement === this.element)) {
-      throw Error(`ElementDOMSlot.removeChild: dom is not in element`);
+      formatDevErrorMessage(`ElementDOMSlot.removeChild: dom is not in element`);
     }
     this.element.removeChild(dom);
     return this;
@@ -8289,7 +8288,7 @@ class ElementDOMSlot {
    */
   replaceChild(dom, prevDom) {
     if (!(prevDom.parentElement === this.element)) {
-      throw Error(`ElementDOMSlot.replaceChild: prevDom is not in element`);
+      formatDevErrorMessage(`ElementDOMSlot.replaceChild: prevDom is not in element`);
     }
     this.element.replaceChild(dom, prevDom);
     return this;
@@ -8408,7 +8407,7 @@ function indexPath(root, child) {
     path.push(i);
   }
   if (!(node === root)) {
-    throw Error(`indexPath: root is not a parent of child`);
+    formatDevErrorMessage(`indexPath: root is not a parent of child`);
   }
   return path.reverse();
 }
@@ -8567,7 +8566,7 @@ class ElementNode extends LexicalNode {
     const firstChild = this.getFirstChild();
     if (firstChild === null) {
       {
-        throw Error(`Expected node ${this.__key} to have a first child.`);
+        formatDevErrorMessage(`Expected node ${this.__key} to have a first child.`);
       }
     }
     return firstChild;
@@ -8581,7 +8580,7 @@ class ElementNode extends LexicalNode {
     const lastChild = this.getLastChild();
     if (lastChild === null) {
       {
-        throw Error(`Expected node ${this.__key} to have a last child.`);
+        formatDevErrorMessage(`Expected node ${this.__key} to have a last child.`);
       }
     }
     return lastChild;
@@ -8762,7 +8761,7 @@ class ElementNode extends LexicalNode {
     const oldSize = this.getChildrenSize();
     const writableSelf = this.getWritable();
     if (!(start + deleteCount <= oldSize)) {
-      throw Error(`ElementNode.splice: start + deleteCount > oldSize (${String(start)} + ${String(deleteCount)} > ${String(oldSize)})`);
+      formatDevErrorMessage(`ElementNode.splice: start + deleteCount > oldSize (${String(start)} + ${String(deleteCount)} > ${String(oldSize)})`);
     }
     const writableSelfKey = writableSelf.__key;
     const nodesToInsertKeys = [];
@@ -8785,7 +8784,7 @@ class ElementNode extends LexicalNode {
       for (let i = 0; i < deleteCount; i++) {
         if (nodeToDelete === null) {
           {
-            throw Error(`splice: sibling not found`);
+            formatDevErrorMessage(`splice: sibling not found`);
           }
         }
         const nextSibling = nodeToDelete.getNextSibling();
@@ -8818,7 +8817,7 @@ class ElementNode extends LexicalNode {
       }
       if (nodeToInsert.__key === writableSelfKey) {
         {
-          throw Error(`append: attempting to append self`);
+          formatDevErrorMessage(`append: attempting to append self`);
         }
       }
       // Set child parent to self
@@ -9038,15 +9037,6 @@ function isPointRemoved(point, nodesToRemoveKeySet, nodesToInsertKeySet) {
   return false;
 }
 
-/**
- * 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.
- *
- */
-
-
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 
 /** @noInheritDoc */
@@ -9057,7 +9047,7 @@ class DecoratorNode extends LexicalNode {
    */
   decorate(editor, config) {
     {
-      throw Error(`decorate: base method not extended`);
+      formatDevErrorMessage(`decorate: base method not extended`);
     }
   }
   isIsolated() {
@@ -9074,14 +9064,6 @@ function $isDecoratorNode(node) {
   return node instanceof DecoratorNode;
 }
 
-/**
- * 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.
- *
- */
-
 /** @noInheritDoc */
 class RootNode extends ElementNode {
   /** @internal */
@@ -9098,7 +9080,7 @@ class RootNode extends ElementNode {
   }
   getTopLevelElementOrThrow() {
     {
-      throw Error(`getTopLevelElementOrThrow: root nodes are not top level elements`);
+      formatDevErrorMessage(`getTopLevelElementOrThrow: root nodes are not top level elements`);
     }
   }
   getTextContent() {
@@ -9112,22 +9094,22 @@ class RootNode extends ElementNode {
   }
   remove() {
     {
-      throw Error(`remove: cannot be called on root nodes`);
+      formatDevErrorMessage(`remove: cannot be called on root nodes`);
     }
   }
   replace(node) {
     {
-      throw Error(`replace: cannot be called on root nodes`);
+      formatDevErrorMessage(`replace: cannot be called on root nodes`);
     }
   }
   insertBefore(nodeToInsert) {
     {
-      throw Error(`insertBefore: cannot be called on root nodes`);
+      formatDevErrorMessage(`insertBefore: cannot be called on root nodes`);
     }
   }
   insertAfter(nodeToInsert) {
     {
-      throw Error(`insertAfter: cannot be called on root nodes`);
+      formatDevErrorMessage(`insertAfter: cannot be called on root nodes`);
     }
   }
 
@@ -9144,7 +9126,7 @@ class RootNode extends ElementNode {
       const node = nodesToAppend[i];
       if (!$isElementNode(node) && !$isDecoratorNode(node)) {
         {
-          throw Error(`rootNode.append: Only element or decorator nodes can be appended to the root node`);
+          formatDevErrorMessage(`rootNode.append: Only element or decorator nodes can be appended to the root node`);
         }
       }
     }
@@ -9165,14 +9147,6 @@ function $isRootNode(node) {
   return node instanceof RootNode;
 }
 
-/**
- * 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 editorStateHasDirtySelection(editorState, editor) {
   const currentSelection = editor.getEditorState()._selection;
   const pendingSelection = editorState._selection;
@@ -9198,14 +9172,14 @@ function exportNodeToJSON(node) {
   const nodeClass = node.constructor;
   if (serializedNode.type !== nodeClass.getType()) {
     {
-      throw Error(`LexicalNode: Node ${nodeClass.name} does not match the serialized type. Check if .exportJSON() is implemented and it is returning the correct type.`);
+      formatDevErrorMessage(`LexicalNode: Node ${nodeClass.name} does not match the serialized type. Check if .exportJSON() is implemented and it is returning the correct type.`);
     }
   }
   if ($isElementNode(node)) {
     const serializedChildren = serializedNode.children;
     if (!Array.isArray(serializedChildren)) {
       {
-        throw Error(`LexicalNode: Node ${nodeClass.name} is an element but .exportJSON() does not have a children array.`);
+        formatDevErrorMessage(`LexicalNode: Node ${nodeClass.name} is an element but .exportJSON() does not have a children array.`);
       }
     }
     const children = node.getChildren();
@@ -9386,15 +9360,6 @@ function $isParagraphNode(node) {
   return node instanceof ParagraphNode;
 }
 
-/**
- * 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.
- *
- */
-
-
 // https://github.com/microsoft/TypeScript/issues/3841
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 
@@ -9533,7 +9498,7 @@ function createEditor(editorConfig) {
         const name = klass.name;
         if (replaceWithKlass) {
           if (!(replaceWithKlass.prototype instanceof klass)) {
-            throw Error(`${replaceWithKlass.name} doesn't extend the ${name}`);
+            formatDevErrorMessage(`${replaceWithKlass.name} doesn't extend the ${name}`);
           }
         }
         if (name !== 'RootNode' && nodeType !== 'root' && nodeType !== 'artificial') {
@@ -9818,7 +9783,7 @@ class LexicalEditor {
   registerCommand(command, listener, priority) {
     if (priority === undefined) {
       {
-        throw Error(`Listener for type "command" requires a "priority".`);
+        formatDevErrorMessage(`Listener for type "command" requires a "priority".`);
       }
     }
     const commandsMap = this._commands;
@@ -9828,7 +9793,7 @@ class LexicalEditor {
     const listenersInPriorityOrder = commandsMap.get(command);
     if (listenersInPriorityOrder === undefined) {
       {
-        throw Error(`registerCommand: Command ${String(command)} not found in command map`);
+        formatDevErrorMessage(`registerCommand: Command ${String(command)} not found in command map`);
       }
     }
     const listeners = listenersInPriorityOrder[priority];
@@ -9877,7 +9842,7 @@ class LexicalEditor {
     const registeredNode = this._nodes.get(klass.getType());
     if (registeredNode === undefined) {
       {
-        throw Error(`Node ${klass.name} has not been registered. Ensure node has been passed to createEditor.`);
+        formatDevErrorMessage(`Node ${klass.name} has not been registered. Ensure node has been passed to createEditor.`);
       }
     }
     return registeredNode;
@@ -10086,7 +10051,7 @@ class LexicalEditor {
   setEditorState(editorState, options) {
     if (editorState.isEmpty()) {
       {
-        throw Error(`setEditorState: the editor state is empty. Ensure the editor state's root node never becomes empty.`);
+        formatDevErrorMessage(`setEditorState: the editor state is empty. Ensure the editor state's root node never becomes empty.`);
       }
     }
 
@@ -10256,15 +10221,7 @@ class LexicalEditor {
     };
   }
 }
-LexicalEditor.version = "0.25.1-nightly.20250228.0+dev.cjs";
-
-/**
- * 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.
- *
- */
+LexicalEditor.version = "0.26.1-nightly.20250303.0+dev.cjs";
 
 let keyCounter = 1;
 function resetRandomKey() {
@@ -10277,7 +10234,7 @@ function getRegisteredNodeOrThrow(editor, nodeType) {
   const registeredNode = editor._nodes.get(nodeType);
   if (registeredNode === undefined) {
     {
-      throw Error(`registeredNode: Type ${nodeType} not found`);
+      formatDevErrorMessage(`registeredNode: Type ${nodeType} not found`);
     }
   }
   return registeredNode;
@@ -10430,11 +10387,11 @@ function errorOnNodeKeyConstructorMismatch(node, existingKey) {
     // Lifted condition to if statement because the inverted logic is a bit confusing
     if (node.constructor.name !== existingNode.constructor.name) {
       {
-        throw Error(`Lexical node with constructor ${node.constructor.name} attempted to re-use key from node in active editor state with constructor ${existingNode.constructor.name}. Keys must not be re-used when the type is changed.`);
+        formatDevErrorMessage(`Lexical node with constructor ${node.constructor.name} attempted to re-use key from node in active editor state with constructor ${existingNode.constructor.name}. Keys must not be re-used when the type is changed.`);
       }
     } else {
       {
-        throw Error(`Lexical node with constructor ${node.constructor.name} attempted to re-use key from node in active editor state with different constructor with the same name (possibly due to invalid Hot Module Replacement). Keys must not be re-used when the type is changed.`);
+        formatDevErrorMessage(`Lexical node with constructor ${node.constructor.name} attempted to re-use key from node in active editor state with different constructor with the same name (possibly due to invalid Hot Module Replacement). Keys must not be re-used when the type is changed.`);
       }
     }
   }
@@ -10653,7 +10610,7 @@ function $setSelection(selection) {
     {
       if (Object.isFrozen(selection)) {
         {
-          throw Error(`$setSelection called on frozen selection object. Ensure selection is cloned before passing in.`);
+          formatDevErrorMessage(`$setSelection called on frozen selection object. Ensure selection is cloned before passing in.`);
         }
       }
     }
@@ -11024,7 +10981,7 @@ function setMutatedNode(mutatedNodes, registeredNodes, mutationListeners, node,
   const registeredNode = registeredNodes.get(nodeType);
   if (registeredNode === undefined) {
     {
-      throw Error(`Type ${nodeType} not in registeredNodes`);
+      formatDevErrorMessage(`Type ${nodeType} not in registeredNodes`);
     }
   }
   const klass = registeredNode.klass;
@@ -11109,7 +11066,7 @@ function getElementByKeyOrThrow(editor, key) {
   const element = editor._keyToDOMMap.get(key);
   if (element === undefined) {
     {
-      throw Error(`Reconciliation: could not find DOM element for node key ${key}`);
+      formatDevErrorMessage(`Reconciliation: could not find DOM element for node key ${key}`);
     }
   }
   return element;
@@ -11227,7 +11184,7 @@ function getWindow(editor) {
   const windowObj = editor._window;
   if (windowObj === null) {
     {
-      throw Error(`window object not found`);
+      formatDevErrorMessage(`window object not found`);
     }
   }
   return windowObj;
@@ -11265,7 +11222,7 @@ function $applyNodeReplacement(node) {
   const nodeType = node.constructor.getType();
   const registeredNode = editor._nodes.get(nodeType);
   if (!(registeredNode !== undefined)) {
-    throw Error(`$applyNodeReplacement node ${node.constructor.name} with type ${nodeType} must be registered to the editor. You can do this by passing the node class via the "nodes" array in the editor config.`);
+    formatDevErrorMessage(`$applyNodeReplacement node ${node.constructor.name} with type ${nodeType} must be registered to the editor. You can do this by passing the node class via the "nodes" array in the editor config.`);
   }
   const {
     replace,
@@ -11276,15 +11233,15 @@ function $applyNodeReplacement(node) {
     const replacementNodeKlass = replacementNode.constructor;
     if (replaceWithKlass !== null) {
       if (!(replacementNode instanceof replaceWithKlass)) {
-        throw Error(`$applyNodeReplacement failed. Expected replacement node to be an instance of ${replaceWithKlass.name} with type ${replaceWithKlass.getType()} but returned ${replacementNodeKlass.name} with type ${replacementNodeKlass.getType()} from original node ${node.constructor.name} with type ${nodeType}`);
+        formatDevErrorMessage(`$applyNodeReplacement failed. Expected replacement node to be an instance of ${replaceWithKlass.name} with type ${replaceWithKlass.getType()} but returned ${replacementNodeKlass.name} with type ${replacementNodeKlass.getType()} from original node ${node.constructor.name} with type ${nodeType}`);
       }
     } else {
       if (!(replacementNode instanceof node.constructor && replacementNodeKlass !== node.constructor)) {
-        throw Error(`$applyNodeReplacement failed. Ensure replacement node ${replacementNodeKlass.name} with type ${replacementNodeKlass.getType()} is a subclass of the original node ${node.constructor.name} with type ${nodeType}.`);
+        formatDevErrorMessage(`$applyNodeReplacement failed. Ensure replacement node ${replacementNodeKlass.name} with type ${replacementNodeKlass.getType()} is a subclass of the original node ${node.constructor.name} with type ${nodeType}.`);
       }
     }
     if (!(replacementNode.__key !== node.__key)) {
-      throw Error(`$applyNodeReplacement failed. Ensure that the key argument is *not* used in your replace function (from node ${node.constructor.name} with type ${nodeType} to node ${replacementNodeKlass.name} with type ${replacementNodeKlass.getType()}), Node keys must never be re-used except by the static clone method.`);
+      formatDevErrorMessage(`$applyNodeReplacement failed. Ensure that the key argument is *not* used in your replace function (from node ${node.constructor.name} with type ${nodeType} to node ${replacementNodeKlass.name} with type ${replacementNodeKlass.getType()}), Node keys must never be re-used except by the static clone method.`);
     }
     return replacementNode;
   }
@@ -11294,7 +11251,7 @@ function errorOnInsertTextNodeOnRoot(node, insertNode) {
   const parentNode = node.getParent();
   if ($isRootNode(parentNode) && !$isElementNode(insertNode) && !$isDecoratorNode(insertNode)) {
     {
-      throw Error(`Only element or decorator nodes can be inserted in to the root node`);
+      formatDevErrorMessage(`Only element or decorator nodes can be inserted in to the root node`);
     }
   }
 }
@@ -11302,7 +11259,7 @@ function $getNodeByKeyOrThrow(key) {
   const node = $getNodeByKey(key);
   if (node === null) {
     {
-      throw Error(`Expected node with key ${key} to exist but it's not in the nodeMap.`);
+      formatDevErrorMessage(`Expected node with key ${key} to exist but it's not in the nodeMap.`);
     }
   }
   return node;
@@ -11407,7 +11364,7 @@ function $splitNode(node, offset) {
     startNode = node;
   }
   if (!!$isRootOrShadowRoot(node)) {
-    throw Error(`Can not call $splitNode() on root element`);
+    formatDevErrorMessage(`Can not call $splitNode() on root element`);
   }
   const recurse = currentNode => {
     const parent = currentNode.getParentOrThrow();
@@ -11417,7 +11374,7 @@ function $splitNode(node, offset) {
     const nodeToMove = currentNode === startNode && !isParentRoot ? currentNode : $copyNode(currentNode);
     if (isParentRoot) {
       if (!($isElementNode(currentNode) && $isElementNode(nodeToMove))) {
-        throw Error(`Children of a root must be ElementNode`);
+        formatDevErrorMessage(`Children of a root must be ElementNode`);
       }
       currentNode.insertAfter(nodeToMove);
       return [currentNode, nodeToMove, nodeToMove];
@@ -11549,7 +11506,7 @@ function getCachedTypeToNodeMap(editorState) {
     return EMPTY_TYPE_TO_NODE_MAP;
   }
   if (!editorState._readOnly) {
-    throw Error(`getCachedTypeToNodeMap called with a writable EditorState`);
+    formatDevErrorMessage(`getCachedTypeToNodeMap called with a writable EditorState`);
   }
   let typeToNodeMap = cachedNodeMaps.get(editorState);
   if (!typeToNodeMap) {
@@ -11596,10 +11553,10 @@ function $cloneWithProperties(latestNode) {
   mutableNode.afterCloneFrom(latestNode);
   {
     if (!(mutableNode.__key === latestNode.__key)) {
-      throw Error(`$cloneWithProperties: ${constructor.name}.clone(node) (with type '${constructor.getType()}') did not return a node with the same key, make sure to specify node.__key as the last argument to the constructor`);
+      formatDevErrorMessage(`$cloneWithProperties: ${constructor.name}.clone(node) (with type '${constructor.getType()}') did not return a node with the same key, make sure to specify node.__key as the last argument to the constructor`);
     }
     if (!(mutableNode.__parent === latestNode.__parent && mutableNode.__next === latestNode.__next && mutableNode.__prev === latestNode.__prev)) {
-      throw Error(`$cloneWithProperties: ${constructor.name}.clone(node) (with type '${constructor.getType()}') overrided afterCloneFrom but did not call super.afterCloneFrom(prevNode)`);
+      formatDevErrorMessage(`$cloneWithProperties: ${constructor.name}.clone(node) (with type '${constructor.getType()}') overrided afterCloneFrom but did not call super.afterCloneFrom(prevNode)`);
     }
   }
   return mutableNode;
@@ -11631,15 +11588,6 @@ function isDOMUnmanaged(elementDom) {
   return el.__lexicalUnmanaged === true;
 }
 
-/**
- * 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.
- *
- */
-
-
 /**
  * The direction of a caret, 'next' points towards the end of the document
  * and 'previous' points towards the beginning
@@ -11806,7 +11754,7 @@ class AbstractCaret {
           }
         } else {
           if (!(target !== null)) {
-            throw Error(`NodeCaret.splice: Underflow of expected nodesToRemove during splice (keys: ${Array.from(nodesToRemove).join(' ')})`);
+            formatDevErrorMessage(`NodeCaret.splice: Underflow of expected nodesToRemove during splice (keys: ${Array.from(nodesToRemove).join(' ')})`);
           }
         }
       } else {
@@ -12084,7 +12032,7 @@ function $getTextNodeOffset(origin, offset) {
   const size = origin.getTextContentSize();
   const numericOffset = offset === 'next' ? size : offset === 'previous' ? 0 : offset;
   if (!(numericOffset >= 0 && numericOffset <= size)) {
-    throw Error(`$getTextNodeOffset: invalid offset ${String(offset)} for size ${String(size)}`);
+    formatDevErrorMessage(`$getTextNodeOffset: invalid offset ${String(offset)} for size ${String(size)}`);
   }
   return numericOffset;
 }
@@ -12263,7 +12211,7 @@ function $extendCaretToRange(anchor) {
  */
 function $getCaretRange(anchor, focus) {
   if (!(anchor.direction === focus.direction)) {
-    throw Error(`$getCaretRange: anchor and focus must be in the same direction`);
+    formatDevErrorMessage(`$getCaretRange: anchor and focus must be in the same direction`);
   }
   return new CaretRangeImpl(anchor, focus, anchor.direction);
 }
@@ -12341,7 +12289,7 @@ function compareNumber(a, b) {
 function $comparePointCaretNext(a, b) {
   const compare = $getCommonAncestor(a.origin, b.origin);
   if (!(compare !== null)) {
-    throw Error(`$comparePointCaretNext: a (key ${a.origin.getKey()}) and b (key ${b.origin.getKey()}) do not have a common ancestor`);
+    formatDevErrorMessage(`$comparePointCaretNext: a (key ${a.origin.getKey()}) and b (key ${b.origin.getKey()}) do not have a common ancestor`);
   }
   switch (compare.type) {
     case 'same':
@@ -12446,7 +12394,7 @@ function $getCommonAncestor(a, b) {
     if (aChild === undefined) ; else if (aChild === null) {
       // a is the ancestor
       if (!$isSameNode(a, parent)) {
-        throw Error(`$originComparison: ancestor logic error`);
+        formatDevErrorMessage(`$originComparison: ancestor logic error`);
       }
       return {
         commonAncestor: parent,
@@ -12455,7 +12403,7 @@ function $getCommonAncestor(a, b) {
     } else if (child === null) {
       // b is the ancestor
       if (!$isSameNode(b, parent)) {
-        throw Error(`$originComparison: descendant logic error`);
+        formatDevErrorMessage(`$originComparison: descendant logic error`);
       }
       return {
         commonAncestor: parent,
@@ -12463,7 +12411,7 @@ function $getCommonAncestor(a, b) {
       };
     } else {
       if (!(($isElementNode(aChild) || $isSameNode(a, aChild)) && ($isElementNode(child) || $isSameNode(b, child)) && parent.is(aChild.getParent()) && parent.is(child.getParent()))) {
-        throw Error(`$originComparison: branch logic error`);
+        formatDevErrorMessage(`$originComparison: branch logic error`);
       }
       return {
         a: aChild,
@@ -12476,15 +12424,6 @@ function $getCommonAncestor(a, b) {
   return null;
 }
 
-/**
- * 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.
- *
- */
-
-
 /**
  * @param point
  * @returns a PointCaret for the point
@@ -12498,12 +12437,12 @@ function $caretFromPoint(point, direction) {
   const node = $getNodeByKeyOrThrow(point.key);
   if (type === 'text') {
     if (!$isTextNode(node)) {
-      throw Error(`$caretFromPoint: Node with type ${node.getType()} and key ${key} that does not inherit from TextNode encountered for text point`);
+      formatDevErrorMessage(`$caretFromPoint: Node with type ${node.getType()} and key ${key} that does not inherit from TextNode encountered for text point`);
     }
     return $getTextPointCaret(node, direction, offset);
   }
   if (!$isElementNode(node)) {
-    throw Error(`$caretFromPoint: Node with type ${node.getType()} and key ${key} that does not inherit from ElementNode encountered for element point`);
+    formatDevErrorMessage(`$caretFromPoint: Node with type ${node.getType()} and key ${key} that does not inherit from ElementNode encountered for element point`);
   }
   return $getChildCaretAtIndex(node, point.offset, direction);
 }
@@ -12530,7 +12469,7 @@ function $setPointFromCaret(point, caret) {
     }
   } else {
     if (!($isChildCaret(caret) && $isElementNode(origin))) {
-      throw Error(`$setPointFromCaret: exhaustiveness check`);
+      formatDevErrorMessage(`$setPointFromCaret: exhaustiveness check`);
     }
     point.set(origin.getKey(), isNext ? 0 : origin.getChildrenSize(), 'element');
   }
@@ -12568,8 +12507,10 @@ function $caretRangeFromSelection(selection) {
     anchor,
     focus
   } = selection;
-  const direction = focus.isBefore(anchor) ? 'previous' : 'next';
-  return $getCaretRange($caretFromPoint(anchor, direction), $caretFromPoint(focus, direction));
+  const anchorCaret = $caretFromPoint(anchor, 'next');
+  const focusCaret = $caretFromPoint(focus, 'next');
+  const direction = $comparePointCaretNext(anchorCaret, focusCaret) <= 0 ? 'next' : 'previous';
+  return $getCaretRange($getCaretInDirection(anchorCaret, direction), $getCaretInDirection(focusCaret, direction));
 }
 
 /**
@@ -12719,7 +12660,7 @@ function $removeTextFromCaretRange(initialRange, sliceMode = 'removeEmptySlices'
     return $getCaretRange(anchor, anchor);
   }
   {
-    throw Error(`$removeTextFromCaretRange: selection was lost, could not find a new anchor given candidates with keys: ${JSON.stringify(anchorCandidates.map(n => n.origin.__key))}`);
+    formatDevErrorMessage(`$removeTextFromCaretRange: selection was lost, could not find a new anchor given candidates with keys: ${JSON.stringify(anchorCandidates.map(n => n.origin.__key))}`);
   }
 }
 
@@ -12816,6 +12757,17 @@ function $normalizeCaret(initialCaret) {
   const adj = caret.getAdjacentCaret();
   return $isSiblingCaret(adj) && $isTextNode(adj.origin) ? $getTextPointCaret(adj.origin, direction, flipDirection(direction)) : caret;
 }
+/**
+ * Determine whether the TextPointCaret's offset can be extended further without leaving the TextNode.
+ * Returns false if the given caret is not a TextPointCaret or the offset can not be moved further in
+ * direction.
+ *
+ * @param caret A PointCaret
+ * @returns true if caret is a TextPointCaret with an offset that is not at the end of the text given the direction.
+ */
+function $isExtendableTextPointCaret(caret) {
+  return $isTextPointCaret(caret) && caret.offset !== $getTextNodeOffset(caret.origin, caret.direction);
+}
 
 /**
  * Return the caret if it's in the given direction, otherwise return
@@ -12944,6 +12896,7 @@ exports.$isBlockElementNode = $isBlockElementNode;
 exports.$isChildCaret = $isChildCaret;
 exports.$isDecoratorNode = $isDecoratorNode;
 exports.$isElementNode = $isElementNode;
+exports.$isExtendableTextPointCaret = $isExtendableTextPointCaret;
 exports.$isInlineElementOrDecoratorNode = $isInlineElementOrDecoratorNode;
 exports.$isLeafNode = $isLeafNode;
 exports.$isLineBreakNode = $isLineBreakNode;