lexical 0.38.3-nightly.20251106.0 → 0.38.3-nightly.20251110.0

package/Lexical.dev.js

@@ -1929,6 +1929,10 @@ function createCommand(type) {
 const SELECTION_CHANGE_COMMAND = createCommand('SELECTION_CHANGE_COMMAND');
 const SELECTION_INSERT_CLIPBOARD_NODES_COMMAND = createCommand('SELECTION_INSERT_CLIPBOARD_NODES_COMMAND');
 const CLICK_COMMAND = createCommand('CLICK_COMMAND');
+const BEFORE_INPUT_COMMAND = createCommand('BEFORE_INPUT_COMMAND');
+const INPUT_COMMAND = createCommand('INPUT_COMMAND');
+const COMPOSITION_START_COMMAND = createCommand('COMPOSITION_START_COMMAND');
+const COMPOSITION_END_COMMAND = createCommand('COMPOSITION_END_COMMAND');
 /**
  * Dispatched to delete a character, the payload will be `true` if the deletion
  * is backwards (backspace or delete on macOS) and `false` if forwards
@@ -2360,9 +2364,15 @@ function $canRemoveText(anchorNode, focusNode) {
 function isPossiblyAndroidKeyPress(timeStamp) {
   return lastKeyCode === 'MediaLast' && timeStamp < lastKeyDownTimeStamp + ANDROID_COMPOSITION_LATENCY;
 }
+function registerDefaultCommandHandlers(editor) {
+  editor.registerCommand(BEFORE_INPUT_COMMAND, $handleBeforeInput, COMMAND_PRIORITY_EDITOR);
+  editor.registerCommand(INPUT_COMMAND, $handleInput, COMMAND_PRIORITY_EDITOR);
+  editor.registerCommand(COMPOSITION_START_COMMAND, $handleCompositionStart, COMMAND_PRIORITY_EDITOR);
+  editor.registerCommand(COMPOSITION_END_COMMAND, $handleCompositionEnd, COMMAND_PRIORITY_EDITOR);
+  editor.registerCommand(KEY_DOWN_COMMAND, $handleKeyDown, COMMAND_PRIORITY_EDITOR);
+}
 function onBeforeInput(event, editor) {
   const inputType = event.inputType;
-  const targetRange = getTargetRange(event);
 
   // We let the browser do its own thing for composition.
   if (inputType === 'deleteCompositionText' ||
@@ -2376,237 +2386,242 @@ function onBeforeInput(event, editor) {
   } else if (inputType === 'insertCompositionText') {
     return;
   }
-  updateEditorSync(editor, () => {
-    const selection = $getSelection();
-    if (inputType === 'deleteContentBackward') {
-      if (selection === null) {
-        // Use previous selection
-        const prevSelection = $getPreviousSelection();
-        if (!$isRangeSelection(prevSelection)) {
-          return;
-        }
-        $setSelection(prevSelection.clone());
+  dispatchCommand(editor, BEFORE_INPUT_COMMAND, event);
+}
+function $handleBeforeInput(event) {
+  const inputType = event.inputType;
+  const targetRange = getTargetRange(event);
+  const editor = getActiveEditor();
+  const selection = $getSelection();
+  if (inputType === 'deleteContentBackward') {
+    if (selection === null) {
+      // Use previous selection
+      const prevSelection = $getPreviousSelection();
+      if (!$isRangeSelection(prevSelection)) {
+        return true;
       }
-      if ($isRangeSelection(selection)) {
-        const isSelectionAnchorSameAsFocus = selection.anchor.key === selection.focus.key;
-        if (isPossiblyAndroidKeyPress(event.timeStamp) && editor.isComposing() && isSelectionAnchorSameAsFocus) {
-          $setCompositionKey(null);
-          lastKeyDownTimeStamp = 0;
-          // Fixes an Android bug where selection flickers when backspacing
-          setTimeout(() => {
-            updateEditorSync(editor, () => {
-              $setCompositionKey(null);
-            });
-          }, ANDROID_COMPOSITION_LATENCY);
-          if ($isRangeSelection(selection)) {
-            const anchorNode = selection.anchor.getNode();
-            anchorNode.markDirty();
-            if (!$isTextNode(anchorNode)) {
-              formatDevErrorMessage(`Anchor node must be a TextNode`);
-            }
-            $updateSelectionFormatStyleFromTextNode(selection, anchorNode);
-          }
-        } else {
-          $setCompositionKey(null);
-          event.preventDefault();
-          // Chromium Android at the moment seems to ignore the preventDefault
-          // on 'deleteContentBackward' and still deletes the content. Which leads
-          // to multiple deletions. So we let the browser handle the deletion in this case.
-          const selectedNode = selection.anchor.getNode();
-          const selectedNodeText = selectedNode.getTextContent();
-          // When the target node has `canInsertTextAfter` set to false, the first deletion
-          // doesn't have an effect, so we need to handle it with Lexical.
-          const selectedNodeCanInsertTextAfter = selectedNode.canInsertTextAfter();
-          const hasSelectedAllTextInNode = selection.anchor.offset === 0 && selection.focus.offset === selectedNodeText.length;
-          let shouldLetBrowserHandleDelete = IS_ANDROID_CHROME && isSelectionAnchorSameAsFocus && !hasSelectedAllTextInNode && selectedNodeCanInsertTextAfter;
-          // Check if selection is collapsed and if the previous node is a decorator node
-          // If so, the browser will not be able to handle the deletion
-          if (shouldLetBrowserHandleDelete && selection.isCollapsed()) {
-            shouldLetBrowserHandleDelete = !$isDecoratorNode($getAdjacentNode(selection.anchor, true));
+      $setSelection(prevSelection.clone());
+    }
+    if ($isRangeSelection(selection)) {
+      const isSelectionAnchorSameAsFocus = selection.anchor.key === selection.focus.key;
+      if (isPossiblyAndroidKeyPress(event.timeStamp) && editor.isComposing() && isSelectionAnchorSameAsFocus) {
+        $setCompositionKey(null);
+        lastKeyDownTimeStamp = 0;
+        // Fixes an Android bug where selection flickers when backspacing
+        setTimeout(() => {
+          updateEditorSync(editor, () => {
+            $setCompositionKey(null);
+          });
+        }, ANDROID_COMPOSITION_LATENCY);
+        if ($isRangeSelection(selection)) {
+          const anchorNode = selection.anchor.getNode();
+          anchorNode.markDirty();
+          if (!$isTextNode(anchorNode)) {
+            formatDevErrorMessage(`Anchor node must be a TextNode`);
           }
-          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);
-            }
+          $updateSelectionFormatStyleFromTextNode(selection, anchorNode);
+        }
+      } else {
+        $setCompositionKey(null);
+        event.preventDefault();
+        // Chromium Android at the moment seems to ignore the preventDefault
+        // on 'deleteContentBackward' and still deletes the content. Which leads
+        // to multiple deletions. So we let the browser handle the deletion in this case.
+        const selectedNode = selection.anchor.getNode();
+        const selectedNodeText = selectedNode.getTextContent();
+        // When the target node has `canInsertTextAfter` set to false, the first deletion
+        // doesn't have an effect, so we need to handle it with Lexical.
+        const selectedNodeCanInsertTextAfter = selectedNode.canInsertTextAfter();
+        const hasSelectedAllTextInNode = selection.anchor.offset === 0 && selection.focus.offset === selectedNodeText.length;
+        let shouldLetBrowserHandleDelete = IS_ANDROID_CHROME && isSelectionAnchorSameAsFocus && !hasSelectedAllTextInNode && selectedNodeCanInsertTextAfter;
+        // Check if selection is collapsed and if the previous node is a decorator node
+        // If so, the browser will not be able to handle the deletion
+        if (shouldLetBrowserHandleDelete && selection.isCollapsed()) {
+          shouldLetBrowserHandleDelete = !$isDecoratorNode($getAdjacentNode(selection.anchor, true));
+        }
+        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;
       }
+      return true;
     }
-    if (!$isRangeSelection(selection)) {
-      return;
-    }
-    const data = event.data;
+  }
+  if (!$isRangeSelection(selection)) {
+    return true;
+  }
+  const data = event.data;
 
-    // This represents the case when two beforeinput events are triggered at the same time (without a
-    // full event loop ending at input). This happens with MacOS with the default keyboard settings,
-    // a combination of autocorrection + autocapitalization.
-    // Having Lexical run everything in controlled mode would fix the issue without additional code
-    // but this would kill the massive performance win from the most common typing event.
-    // Alternatively, when this happens we can prematurely update our EditorState based on the DOM
-    // content, a job that would usually be the input event's responsibility.
-    if (unprocessedBeforeInputData !== null) {
-      $updateSelectedTextFromDOM(false, editor, unprocessedBeforeInputData);
-    }
-    if ((!selection.dirty || unprocessedBeforeInputData !== null) && selection.isCollapsed() && !$isRootNode(selection.anchor.getNode()) && targetRange !== null) {
-      selection.applyDOMRange(targetRange);
+  // This represents the case when two beforeinput events are triggered at the same time (without a
+  // full event loop ending at input). This happens with MacOS with the default keyboard settings,
+  // a combination of autocorrection + autocapitalization.
+  // Having Lexical run everything in controlled mode would fix the issue without additional code
+  // but this would kill the massive performance win from the most common typing event.
+  // Alternatively, when this happens we can prematurely update our EditorState based on the DOM
+  // content, a job that would usually be the input event's responsibility.
+  if (unprocessedBeforeInputData !== null) {
+    $updateSelectedTextFromDOM(false, editor, unprocessedBeforeInputData);
+  }
+  if ((!selection.dirty || unprocessedBeforeInputData !== null) && selection.isCollapsed() && !$isRootNode(selection.anchor.getNode()) && targetRange !== null) {
+    selection.applyDOMRange(targetRange);
+  }
+  unprocessedBeforeInputData = null;
+  const anchor = selection.anchor;
+  const focus = selection.focus;
+  const anchorNode = anchor.getNode();
+  const focusNode = focus.getNode();
+  if (inputType === 'insertText' || inputType === 'insertTranspose') {
+    if (data === '\n') {
+      event.preventDefault();
+      dispatchCommand(editor, INSERT_LINE_BREAK_COMMAND, false);
+    } else if (data === DOUBLE_LINE_BREAK) {
+      event.preventDefault();
+      dispatchCommand(editor, INSERT_PARAGRAPH_COMMAND, undefined);
+    } else if (data == null && event.dataTransfer) {
+      // Gets around a Safari text replacement bug.
+      const text = event.dataTransfer.getData('text/plain');
+      event.preventDefault();
+      selection.insertRawText(text);
+    } else if (data != null && $shouldPreventDefaultAndInsertText(selection, targetRange, data, event.timeStamp, true)) {
+      event.preventDefault();
+      dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, data);
+    } else {
+      unprocessedBeforeInputData = data;
     }
-    unprocessedBeforeInputData = null;
-    const anchor = selection.anchor;
-    const focus = selection.focus;
-    const anchorNode = anchor.getNode();
-    const focusNode = focus.getNode();
-    if (inputType === 'insertText' || inputType === 'insertTranspose') {
-      if (data === '\n') {
-        event.preventDefault();
+    lastBeforeInputInsertTextTimeStamp = event.timeStamp;
+    return true;
+  }
+
+  // Prevent the browser from carrying out
+  // the input event, so we can control the
+  // output.
+  event.preventDefault();
+  switch (inputType) {
+    case 'insertFromYank':
+    case 'insertFromDrop':
+    case 'insertReplacementText':
+      {
+        dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, event);
+        break;
+      }
+    case 'insertFromComposition':
+      {
+        // This is the end of composition
+        $setCompositionKey(null);
+        dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, event);
+        break;
+      }
+    case 'insertLineBreak':
+      {
+        // Used for Android
+        $setCompositionKey(null);
         dispatchCommand(editor, INSERT_LINE_BREAK_COMMAND, false);
-      } else if (data === DOUBLE_LINE_BREAK) {
-        event.preventDefault();
-        dispatchCommand(editor, INSERT_PARAGRAPH_COMMAND, undefined);
-      } else if (data == null && event.dataTransfer) {
-        // Gets around a Safari text replacement bug.
-        const text = event.dataTransfer.getData('text/plain');
-        event.preventDefault();
-        selection.insertRawText(text);
-      } else if (data != null && $shouldPreventDefaultAndInsertText(selection, targetRange, data, event.timeStamp, true)) {
-        event.preventDefault();
-        dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, data);
-      } else {
-        unprocessedBeforeInputData = data;
+        break;
       }
-      lastBeforeInputInsertTextTimeStamp = event.timeStamp;
-      return;
-    }
+    case 'insertParagraph':
+      {
+        // Used for Android
+        $setCompositionKey(null);
 
-    // Prevent the browser from carrying out
-    // the input event, so we can control the
-    // output.
-    event.preventDefault();
-    switch (inputType) {
-      case 'insertFromYank':
-      case 'insertFromDrop':
-      case 'insertReplacementText':
-        {
-          dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, event);
-          break;
-        }
-      case 'insertFromComposition':
-        {
-          // This is the end of composition
-          $setCompositionKey(null);
-          dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, event);
-          break;
-        }
-      case 'insertLineBreak':
-        {
-          // Used for Android
-          $setCompositionKey(null);
+        // Safari does not provide the type "insertLineBreak".
+        // So instead, we need to infer it from the keyboard event.
+        // We do not apply this logic to iOS to allow newline auto-capitalization
+        // work without creating linebreaks when pressing Enter
+        if (isInsertLineBreak && !IS_IOS) {
+          isInsertLineBreak = false;
           dispatchCommand(editor, INSERT_LINE_BREAK_COMMAND, false);
-          break;
-        }
-      case 'insertParagraph':
-        {
-          // Used for Android
-          $setCompositionKey(null);
-
-          // Safari does not provide the type "insertLineBreak".
-          // So instead, we need to infer it from the keyboard event.
-          // We do not apply this logic to iOS to allow newline auto-capitalization
-          // work without creating linebreaks when pressing Enter
-          if (isInsertLineBreak && !IS_IOS) {
-            isInsertLineBreak = false;
-            dispatchCommand(editor, INSERT_LINE_BREAK_COMMAND, false);
-          } else {
-            dispatchCommand(editor, INSERT_PARAGRAPH_COMMAND, undefined);
-          }
-          break;
-        }
-      case 'insertFromPaste':
-      case 'insertFromPasteAsQuotation':
-        {
-          dispatchCommand(editor, PASTE_COMMAND, event);
-          break;
-        }
-      case 'deleteByComposition':
-        {
-          if ($canRemoveText(anchorNode, focusNode)) {
-            dispatchCommand(editor, REMOVE_TEXT_COMMAND, event);
-          }
-          break;
+        } else {
+          dispatchCommand(editor, INSERT_PARAGRAPH_COMMAND, undefined);
         }
-      case 'deleteByDrag':
-      case 'deleteByCut':
-        {
+        break;
+      }
+    case 'insertFromPaste':
+    case 'insertFromPasteAsQuotation':
+      {
+        dispatchCommand(editor, PASTE_COMMAND, event);
+        break;
+      }
+    case 'deleteByComposition':
+      {
+        if ($canRemoveText(anchorNode, focusNode)) {
           dispatchCommand(editor, REMOVE_TEXT_COMMAND, event);
-          break;
-        }
-      case 'deleteContent':
-        {
-          dispatchCommand(editor, DELETE_CHARACTER_COMMAND, false);
-          break;
-        }
-      case 'deleteWordBackward':
-        {
-          dispatchCommand(editor, DELETE_WORD_COMMAND, true);
-          break;
-        }
-      case 'deleteWordForward':
-        {
-          dispatchCommand(editor, DELETE_WORD_COMMAND, false);
-          break;
-        }
-      case 'deleteHardLineBackward':
-      case 'deleteSoftLineBackward':
-        {
-          dispatchCommand(editor, DELETE_LINE_COMMAND, true);
-          break;
-        }
-      case 'deleteContentForward':
-      case 'deleteHardLineForward':
-      case 'deleteSoftLineForward':
-        {
-          dispatchCommand(editor, DELETE_LINE_COMMAND, false);
-          break;
-        }
-      case 'formatStrikeThrough':
-        {
-          dispatchCommand(editor, FORMAT_TEXT_COMMAND, 'strikethrough');
-          break;
         }
-      case 'formatBold':
-        {
-          dispatchCommand(editor, FORMAT_TEXT_COMMAND, 'bold');
-          break;
-        }
-      case 'formatItalic':
-        {
-          dispatchCommand(editor, FORMAT_TEXT_COMMAND, 'italic');
-          break;
-        }
-      case 'formatUnderline':
-        {
-          dispatchCommand(editor, FORMAT_TEXT_COMMAND, 'underline');
-          break;
-        }
-      case 'historyUndo':
-        {
-          dispatchCommand(editor, UNDO_COMMAND, undefined);
-          break;
-        }
-      case 'historyRedo':
-        {
-          dispatchCommand(editor, REDO_COMMAND, undefined);
-          break;
-        }
-      // NO-OP
-    }
-  });
+        break;
+      }
+    case 'deleteByDrag':
+    case 'deleteByCut':
+      {
+        dispatchCommand(editor, REMOVE_TEXT_COMMAND, event);
+        break;
+      }
+    case 'deleteContent':
+      {
+        dispatchCommand(editor, DELETE_CHARACTER_COMMAND, false);
+        break;
+      }
+    case 'deleteWordBackward':
+      {
+        dispatchCommand(editor, DELETE_WORD_COMMAND, true);
+        break;
+      }
+    case 'deleteWordForward':
+      {
+        dispatchCommand(editor, DELETE_WORD_COMMAND, false);
+        break;
+      }
+    case 'deleteHardLineBackward':
+    case 'deleteSoftLineBackward':
+      {
+        dispatchCommand(editor, DELETE_LINE_COMMAND, true);
+        break;
+      }
+    case 'deleteContentForward':
+    case 'deleteHardLineForward':
+    case 'deleteSoftLineForward':
+      {
+        dispatchCommand(editor, DELETE_LINE_COMMAND, false);
+        break;
+      }
+    case 'formatStrikeThrough':
+      {
+        dispatchCommand(editor, FORMAT_TEXT_COMMAND, 'strikethrough');
+        break;
+      }
+    case 'formatBold':
+      {
+        dispatchCommand(editor, FORMAT_TEXT_COMMAND, 'bold');
+        break;
+      }
+    case 'formatItalic':
+      {
+        dispatchCommand(editor, FORMAT_TEXT_COMMAND, 'italic');
+        break;
+      }
+    case 'formatUnderline':
+      {
+        dispatchCommand(editor, FORMAT_TEXT_COMMAND, 'underline');
+        break;
+      }
+    case 'historyUndo':
+      {
+        dispatchCommand(editor, UNDO_COMMAND, undefined);
+        break;
+      }
+    case 'historyRedo':
+      {
+        dispatchCommand(editor, REDO_COMMAND, undefined);
+        break;
+      }
+    // NO-OP
+  }
+  return true;
 }
 function onInput(event, editor) {
   // Note that the MutationObserver may or may not have already fired,
@@ -2618,90 +2633,103 @@ function onInput(event, editor) {
   // We don't want the onInput to bubble, in the case of nested editors.
   event.stopPropagation();
   updateEditorSync(editor, () => {
-    if (isHTMLElement(event.target) && $isSelectionCapturedInDecorator(event.target)) {
-      return;
+    editor.dispatchCommand(INPUT_COMMAND, event);
+  }, {
+    event
+  });
+  unprocessedBeforeInputData = null;
+}
+function $handleInput(event) {
+  if (isHTMLElement(event.target) && $isSelectionCapturedInDecorator(event.target)) {
+    return true;
+  }
+  const editor = getActiveEditor();
+  const selection = $getSelection();
+  const data = event.data;
+  const targetRange = getTargetRange(event);
+  if (data != null && $isRangeSelection(selection) && $shouldPreventDefaultAndInsertText(selection, targetRange, data, event.timeStamp, false)) {
+    // Given we're over-riding the default behavior, we will need
+    // to ensure to disable composition before dispatching the
+    // insertText command for when changing the sequence for FF.
+    if (isFirefoxEndingComposition) {
+      $onCompositionEndImpl(editor, data);
+      isFirefoxEndingComposition = false;
     }
-    const selection = $getSelection();
-    const data = event.data;
-    const targetRange = getTargetRange(event);
-    if (data != null && $isRangeSelection(selection) && $shouldPreventDefaultAndInsertText(selection, targetRange, data, event.timeStamp, false)) {
-      // Given we're over-riding the default behavior, we will need
-      // to ensure to disable composition before dispatching the
-      // insertText command for when changing the sequence for FF.
-      if (isFirefoxEndingComposition) {
-        $onCompositionEndImpl(editor, data);
-        isFirefoxEndingComposition = false;
-      }
-      const anchor = selection.anchor;
-      const anchorNode = anchor.getNode();
-      const domSelection = getDOMSelection(getWindow(editor));
-      if (domSelection === null) {
-        return;
-      }
-      const isBackward = selection.isBackward();
-      const startOffset = isBackward ? selection.anchor.offset : selection.focus.offset;
-      const endOffset = isBackward ? selection.focus.offset : selection.anchor.offset;
-      // If the content is the same as inserted, then don't dispatch an insertion.
-      // Given onInput doesn't take the current selection (it uses the previous)
-      // we can compare that against what the DOM currently says.
-      if (!CAN_USE_BEFORE_INPUT || selection.isCollapsed() || !$isTextNode(anchorNode) || domSelection.anchorNode === null || anchorNode.getTextContent().slice(0, startOffset) + data + anchorNode.getTextContent().slice(startOffset + endOffset) !== getAnchorTextFromDOM(domSelection.anchorNode)) {
-        dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, data);
-      }
-      const textLength = data.length;
+    const anchor = selection.anchor;
+    const anchorNode = anchor.getNode();
+    const domSelection = getDOMSelection(getWindow(editor));
+    if (domSelection === null) {
+      return true;
+    }
+    const isBackward = selection.isBackward();
+    const startOffset = isBackward ? selection.anchor.offset : selection.focus.offset;
+    const endOffset = isBackward ? selection.focus.offset : selection.anchor.offset;
+    // If the content is the same as inserted, then don't dispatch an insertion.
+    // Given onInput doesn't take the current selection (it uses the previous)
+    // we can compare that against what the DOM currently says.
+    if (!CAN_USE_BEFORE_INPUT || selection.isCollapsed() || !$isTextNode(anchorNode) || domSelection.anchorNode === null || anchorNode.getTextContent().slice(0, startOffset) + data + anchorNode.getTextContent().slice(startOffset + endOffset) !== getAnchorTextFromDOM(domSelection.anchorNode)) {
+      dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, data);
+    }
+    const textLength = data.length;
 
-      // Another hack for FF, as it's possible that the IME is still
-      // open, even though compositionend has already fired (sigh).
-      if (IS_FIREFOX && textLength > 1 && event.inputType === 'insertCompositionText' && !editor.isComposing()) {
-        selection.anchor.offset -= textLength;
-      }
+    // Another hack for FF, as it's possible that the IME is still
+    // open, even though compositionend has already fired (sigh).
+    if (IS_FIREFOX && textLength > 1 && event.inputType === 'insertCompositionText' && !editor.isComposing()) {
+      selection.anchor.offset -= textLength;
+    }
 
-      // This ensures consistency on Android.
-      if (!IS_SAFARI && !IS_IOS && !IS_APPLE_WEBKIT && editor.isComposing()) {
-        lastKeyDownTimeStamp = 0;
-        $setCompositionKey(null);
-      }
-    } else {
-      const characterData = data !== null ? data : undefined;
-      $updateSelectedTextFromDOM(false, editor, characterData);
+    // This ensures consistency on Android.
+    if (!IS_SAFARI && !IS_IOS && !IS_APPLE_WEBKIT && editor.isComposing()) {
+      lastKeyDownTimeStamp = 0;
+      $setCompositionKey(null);
+    }
+  } else {
+    const characterData = data !== null ? data : undefined;
+    $updateSelectedTextFromDOM(false, editor, characterData);
 
-      // onInput always fires after onCompositionEnd for FF.
-      if (isFirefoxEndingComposition) {
-        $onCompositionEndImpl(editor, data || undefined);
-        isFirefoxEndingComposition = false;
-      }
+    // onInput always fires after onCompositionEnd for FF.
+    if (isFirefoxEndingComposition) {
+      $onCompositionEndImpl(editor, data || undefined);
+      isFirefoxEndingComposition = false;
     }
+  }
 
-    // Also flush any other mutations that might have occurred
-    // since the change.
-    $flushMutations();
-  }, {
-    event
-  });
-  unprocessedBeforeInputData = null;
+  // Also flush any other mutations that might have occurred
+  // since the change.
+  $flushMutations();
+  return true;
 }
 function onCompositionStart(event, editor) {
-  updateEditorSync(editor, () => {
-    const selection = $getSelection();
-    if ($isRangeSelection(selection) && !editor.isComposing()) {
-      const anchor = selection.anchor;
-      const node = selection.anchor.getNode();
-      $setCompositionKey(anchor.key);
-      if (
-      // If it has been 30ms since the last keydown, then we should
-      // apply the empty space heuristic. We can't do this for Safari,
-      // as the keydown fires after composition start.
-      event.timeStamp < lastKeyDownTimeStamp + ANDROID_COMPOSITION_LATENCY ||
-      // FF has issues around composing multibyte characters, so we also
-      // need to invoke the empty space heuristic below.
-      anchor.type === 'element' || !selection.isCollapsed() || node.getFormat() !== selection.format || $isTextNode(node) && node.getStyle() !== selection.style) {
-        // We insert a zero width character, 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
-        // there is no text node matching the selection.
-        dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, COMPOSITION_START_CHAR);
-      }
+  dispatchCommand(editor, COMPOSITION_START_COMMAND, event);
+}
+function $handleCompositionStart(event) {
+  const editor = getActiveEditor();
+  const selection = $getSelection();
+  if ($isRangeSelection(selection) && !editor.isComposing()) {
+    const anchor = selection.anchor;
+    const node = selection.anchor.getNode();
+    $setCompositionKey(anchor.key);
+    if (
+    // If it has been 30ms since the last keydown, then we should
+    // apply the empty space heuristic. We can't do this for Safari,
+    // as the keydown fires after composition start.
+    event.timeStamp < lastKeyDownTimeStamp + ANDROID_COMPOSITION_LATENCY ||
+    // FF has issues around composing multibyte characters, so we also
+    // need to invoke the empty space heuristic below.
+    anchor.type === 'element' || !selection.isCollapsed() || node.getFormat() !== selection.format || $isTextNode(node) && node.getStyle() !== selection.style) {
+      // We insert a zero width character, 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
+      // there is no text node matching the selection.
+      dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, COMPOSITION_START_CHAR);
     }
-  });
+  }
+  return true;
+}
+function $handleCompositionEnd(event) {
+  const editor = getActiveEditor();
+  $onCompositionEndImpl(editor, event.data);
+  return true;
 }
 function $onCompositionEndImpl(editor, data) {
   const compositionKey = editor._compositionKey;
@@ -2753,9 +2781,7 @@ function onCompositionEnd(event, editor) {
     isSafariEndingComposition = true;
     safariEndCompositionEventData = event.data;
   } else {
-    updateEditorSync(editor, () => {
-      $onCompositionEndImpl(editor, event.data);
-    });
+    dispatchCommand(editor, COMPOSITION_END_COMMAND, event);
   }
 }
 function onKeyDown(event, editor) {
@@ -2764,11 +2790,12 @@ function onKeyDown(event, editor) {
   if (editor.isComposing()) {
     return;
   }
-  if (dispatchCommand(editor, KEY_DOWN_COMMAND, event)) {
-    return;
-  }
+  dispatchCommand(editor, KEY_DOWN_COMMAND, event);
+}
+function $handleKeyDown(event) {
+  const editor = getActiveEditor();
   if (event.key == null) {
-    return;
+    return true;
   }
   if (isSafariEndingComposition && isBackspace(event)) {
     updateEditorSync(editor, () => {
@@ -2776,7 +2803,7 @@ function onKeyDown(event, editor) {
     });
     isSafariEndingComposition = false;
     safariEndCompositionEventData = '';
-    return;
+    return true;
   }
   if (isMoveForward(event)) {
     dispatchCommand(editor, KEY_ARROW_RIGHT_COMMAND, event);
@@ -2867,8 +2894,9 @@ function onKeyDown(event, editor) {
     }
   }
   if (isModifier(event)) {
-    dispatchCommand(editor, KEY_MODIFIER_COMMAND, event);
+    editor.dispatchCommand(KEY_MODIFIER_COMMAND, event);
   }
+  return true;
 }
 function getRootElementRemoveHandles(rootElement) {
   // @ts-expect-error: internal field
@@ -10186,6 +10214,7 @@ function createEditor(editorConfig) {
     editor._pendingEditorState = initialEditorState;
     editor._dirtyType = FULL_RECONCILE;
   }
+  registerDefaultCommandHandlers(editor);
   return editor;
 }
 class LexicalEditor {
@@ -10865,7 +10894,7 @@ class LexicalEditor {
     };
   }
 }
-LexicalEditor.version = "0.38.3-nightly.20251106.0+dev.cjs";
+LexicalEditor.version = "0.38.3-nightly.20251110.0+dev.cjs";
 
 let pendingNodeToClone = null;
 function setPendingNodeToClone(pendingNode) {
@@ -14078,6 +14107,7 @@ exports.$splitAtPointCaretNext = $splitAtPointCaretNext;
 exports.$splitNode = $splitNode;
 exports.$updateRangeSelectionFromCaretRange = $updateRangeSelectionFromCaretRange;
 exports.ArtificialNode__DO_NOT_USE = ArtificialNode__DO_NOT_USE;
+exports.BEFORE_INPUT_COMMAND = BEFORE_INPUT_COMMAND;
 exports.BLUR_COMMAND = BLUR_COMMAND;
 exports.CAN_REDO_COMMAND = CAN_REDO_COMMAND;
 exports.CAN_UNDO_COMMAND = CAN_UNDO_COMMAND;
@@ -14090,6 +14120,8 @@ exports.COMMAND_PRIORITY_EDITOR = COMMAND_PRIORITY_EDITOR;
 exports.COMMAND_PRIORITY_HIGH = COMMAND_PRIORITY_HIGH;
 exports.COMMAND_PRIORITY_LOW = COMMAND_PRIORITY_LOW;
 exports.COMMAND_PRIORITY_NORMAL = COMMAND_PRIORITY_NORMAL;
+exports.COMPOSITION_END_COMMAND = COMPOSITION_END_COMMAND;
+exports.COMPOSITION_START_COMMAND = COMPOSITION_START_COMMAND;
 exports.CONTROLLED_TEXT_INSERTION_COMMAND = CONTROLLED_TEXT_INSERTION_COMMAND;
 exports.COPY_COMMAND = COPY_COMMAND;
 exports.CUT_COMMAND = CUT_COMMAND;
@@ -14109,6 +14141,7 @@ exports.HISTORIC_TAG = HISTORIC_TAG;
 exports.HISTORY_MERGE_TAG = HISTORY_MERGE_TAG;
 exports.HISTORY_PUSH_TAG = HISTORY_PUSH_TAG;
 exports.INDENT_CONTENT_COMMAND = INDENT_CONTENT_COMMAND;
+exports.INPUT_COMMAND = INPUT_COMMAND;
 exports.INSERT_LINE_BREAK_COMMAND = INSERT_LINE_BREAK_COMMAND;
 exports.INSERT_PARAGRAPH_COMMAND = INSERT_PARAGRAPH_COMMAND;
 exports.INSERT_TAB_COMMAND = INSERT_TAB_COMMAND;