lexical 0.30.1-nightly.20250414.0 → 0.30.1-nightly.20250416.0

package/Lexical.dev.js

@@ -1786,29 +1786,108 @@ 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');
+/**
+ * Dispatched to delete a character, the payload will be `true` if the deletion
+ * is backwards (backspace or delete on macOS) and `false` if forwards
+ * (delete or Fn+Delete on macOS).
+ */
 const DELETE_CHARACTER_COMMAND = createCommand('DELETE_CHARACTER_COMMAND');
+/**
+ * Dispatched to insert a line break. With a false payload the
+ * cursor moves to the new line (Shift+Enter), with a true payload the cursor
+ * does not move (Ctrl+O on macOS).
+ */
 const INSERT_LINE_BREAK_COMMAND = createCommand('INSERT_LINE_BREAK_COMMAND');
 const INSERT_PARAGRAPH_COMMAND = createCommand('INSERT_PARAGRAPH_COMMAND');
 const CONTROLLED_TEXT_INSERTION_COMMAND = createCommand('CONTROLLED_TEXT_INSERTION_COMMAND');
 const PASTE_COMMAND = createCommand('PASTE_COMMAND');
 const REMOVE_TEXT_COMMAND = createCommand('REMOVE_TEXT_COMMAND');
+/**
+ * Dispatched to delete a word, the payload will be `true` if the deletion is
+ * backwards (Ctrl+Backspace or Opt+Delete on macOS), and `false` if
+ * forwards (Ctrl+Delete or Fn+Opt+Delete on macOS).
+ */
 const DELETE_WORD_COMMAND = createCommand('DELETE_WORD_COMMAND');
+/**
+ * Dispatched to delete a line, the payload will be `true` if the deletion is
+ * backwards (Cmd+Delete on macOS), and `false` if forwards
+ * (Fn+Cmd+Delete on macOS).
+ */
 const DELETE_LINE_COMMAND = createCommand('DELETE_LINE_COMMAND');
+/**
+ * Dispatched to format the selected text.
+ */
 const FORMAT_TEXT_COMMAND = createCommand('FORMAT_TEXT_COMMAND');
+/**
+ * Dispatched on undo (Cmd+Z on macOS, Ctrl+Z elsewhere).
+ */
 const UNDO_COMMAND = createCommand('UNDO_COMMAND');
+/**
+ * Dispatched on redo (Shift+Cmd+Z on macOS, Shift+Ctrl+Z or Ctrl+Y elsewhere).
+ */
 const REDO_COMMAND = createCommand('REDO_COMMAND');
+/**
+ * Dispatched when any key is pressed.
+ */
 const KEY_DOWN_COMMAND = createCommand('KEYDOWN_COMMAND');
+/**
+ * Dispatched when the `'ArrowRight'` key is pressed.
+ * The shift modifier key may also be down.
+ */
 const KEY_ARROW_RIGHT_COMMAND = createCommand('KEY_ARROW_RIGHT_COMMAND');
+/**
+ * Dispatched when the move to end keyboard shortcut is pressed,
+ * (Cmd+Right on macOS; Ctrl+Right elsewhere).
+ */
 const MOVE_TO_END = createCommand('MOVE_TO_END');
+/**
+ * Dispatched when the `'ArrowLeft'` key is pressed.
+ * The shift modifier key may also be down.
+ */
 const KEY_ARROW_LEFT_COMMAND = createCommand('KEY_ARROW_LEFT_COMMAND');
+/**
+ * Dispatched when the move to start keyboard shortcut is pressed,
+ * (Cmd+Left on macOS; Ctrl+Left elsewhere).
+ */
 const MOVE_TO_START = createCommand('MOVE_TO_START');
+/**
+ * Dispatched when the `'ArrowUp'` key is pressed.
+ * The shift and/or alt (option) modifier keys may also be down.
+ */
 const KEY_ARROW_UP_COMMAND = createCommand('KEY_ARROW_UP_COMMAND');
+/**
+ * Dispatched when the `'ArrowUp'` key is pressed.
+ * The shift and/or alt (option) modifier keys may also be down.
+ */
 const KEY_ARROW_DOWN_COMMAND = createCommand('KEY_ARROW_DOWN_COMMAND');
+/**
+ * Dispatched when the enter key is pressed, may also be called with a null
+ * payload when the intent is to insert a newline.
+ */
 const KEY_ENTER_COMMAND = createCommand('KEY_ENTER_COMMAND');
+/**
+ * Dispatched whenever the space (`' '`) key is pressed, any modifier
+ * keys may be down.
+ */
 const KEY_SPACE_COMMAND = createCommand('KEY_SPACE_COMMAND');
+/**
+ * Dispatched whenever the `'Backspace'` key is pressed, the shift
+ * modifier key may be down.
+ */
 const KEY_BACKSPACE_COMMAND = createCommand('KEY_BACKSPACE_COMMAND');
+/**
+ * Dispatched whenever the `'Escape'` key is pressed, any modifier
+ * keys may be down.
+ */
 const KEY_ESCAPE_COMMAND = createCommand('KEY_ESCAPE_COMMAND');
+/**
+ * Dispatched whenever the `'Delete'` key is pressed (Fn+Delete on macOS).
+ */
 const KEY_DELETE_COMMAND = createCommand('KEY_DELETE_COMMAND');
+/**
+ * Dispatched whenever the `'Tab'` key is pressed. The shift modifier key
+ * may be down.
+ */
 const KEY_TAB_COMMAND = createCommand('KEY_TAB_COMMAND');
 const INSERT_TAB_COMMAND = createCommand('INSERT_TAB_COMMAND');
 const INDENT_CONTENT_COMMAND = createCommand('INDENT_CONTENT_COMMAND');
@@ -1818,8 +1897,20 @@ const FORMAT_ELEMENT_COMMAND = createCommand('FORMAT_ELEMENT_COMMAND');
 const DRAGSTART_COMMAND = createCommand('DRAGSTART_COMMAND');
 const DRAGOVER_COMMAND = createCommand('DRAGOVER_COMMAND');
 const DRAGEND_COMMAND = createCommand('DRAGEND_COMMAND');
+/**
+ * Dispatched on a copy event, either via the clipboard or a KeyboardEvent
+ * (Cmd+C on macOS, Ctrl+C elsewhere).
+ */
 const COPY_COMMAND = createCommand('COPY_COMMAND');
+/**
+ * Dispatched on a cut event, either via the clipboard or a KeyboardEvent
+ * (Cmd+X on macOS, Ctrl+X elsewhere).
+ */
 const CUT_COMMAND = createCommand('CUT_COMMAND');
+/**
+ * Dispatched on the select all keyboard shortcut
+ * (Cmd+A on macOS, Ctrl+A elsehwere).
+ */
 const SELECT_ALL_COMMAND = createCommand('SELECT_ALL_COMMAND');
 const CLEAR_EDITOR_COMMAND = createCommand('CLEAR_EDITOR_COMMAND');
 const CLEAR_HISTORY_COMMAND = createCommand('CLEAR_HISTORY_COMMAND');
@@ -2520,20 +2611,13 @@ function onKeyDown(event, editor) {
   if (editor.isComposing()) {
     return;
   }
-  const {
-    key,
-    shiftKey,
-    ctrlKey,
-    metaKey,
-    altKey
-  } = event;
   if (dispatchCommand(editor, KEY_DOWN_COMMAND, event)) {
     return;
   }
-  if (key == null) {
+  if (event.key == null) {
     return;
   }
-  if (isSafariEndingComposition && isBackspace(lastKeyCode)) {
+  if (isSafariEndingComposition && isBackspace(event)) {
     updateEditorSync(editor, () => {
       $onCompositionEndImpl(editor, safariEndCompositionEventData);
     });
@@ -2541,96 +2625,95 @@ function onKeyDown(event, editor) {
     safariEndCompositionEventData = '';
     return;
   }
-  if (isMoveForward(key, ctrlKey, altKey, metaKey)) {
+  if (isMoveForward(event)) {
     dispatchCommand(editor, KEY_ARROW_RIGHT_COMMAND, event);
-  } else if (isMoveToEnd(key, ctrlKey, shiftKey, altKey, metaKey)) {
+  } else if (isMoveToEnd(event)) {
     dispatchCommand(editor, MOVE_TO_END, event);
-  } else if (isMoveBackward(key, ctrlKey, altKey, metaKey)) {
+  } else if (isMoveBackward(event)) {
     dispatchCommand(editor, KEY_ARROW_LEFT_COMMAND, event);
-  } else if (isMoveToStart(key, ctrlKey, shiftKey, altKey, metaKey)) {
+  } else if (isMoveToStart(event)) {
     dispatchCommand(editor, MOVE_TO_START, event);
-  } else if (isMoveUp(key, ctrlKey, metaKey)) {
+  } else if (isMoveUp(event)) {
     dispatchCommand(editor, KEY_ARROW_UP_COMMAND, event);
-  } else if (isMoveDown(key, ctrlKey, metaKey)) {
+  } else if (isMoveDown(event)) {
     dispatchCommand(editor, KEY_ARROW_DOWN_COMMAND, event);
-  } else if (isLineBreak(key, shiftKey)) {
+  } else if (isLineBreak(event)) {
     isInsertLineBreak = true;
     dispatchCommand(editor, KEY_ENTER_COMMAND, event);
-  } else if (isSpace(key)) {
+  } else if (isSpace(event)) {
     dispatchCommand(editor, KEY_SPACE_COMMAND, event);
-  } else if (isOpenLineBreak(key, ctrlKey)) {
+  } else if (isOpenLineBreak(event)) {
     event.preventDefault();
     isInsertLineBreak = true;
     dispatchCommand(editor, INSERT_LINE_BREAK_COMMAND, true);
-  } else if (isParagraph(key, shiftKey)) {
+  } else if (isParagraph(event)) {
     isInsertLineBreak = false;
     dispatchCommand(editor, KEY_ENTER_COMMAND, event);
-  } else if (isDeleteBackward(key, altKey, metaKey, ctrlKey)) {
-    if (isBackspace(key)) {
+  } else if (isDeleteBackward(event)) {
+    if (isBackspace(event)) {
       dispatchCommand(editor, KEY_BACKSPACE_COMMAND, event);
     } else {
       event.preventDefault();
       dispatchCommand(editor, DELETE_CHARACTER_COMMAND, true);
     }
-  } else if (isEscape(key)) {
+  } else if (isEscape(event)) {
     dispatchCommand(editor, KEY_ESCAPE_COMMAND, event);
-  } else if (isDeleteForward(key, ctrlKey, shiftKey, altKey, metaKey)) {
-    if (isDelete(key)) {
+  } else if (isDeleteForward(event)) {
+    if (isDelete(event)) {
       dispatchCommand(editor, KEY_DELETE_COMMAND, event);
     } else {
       event.preventDefault();
       dispatchCommand(editor, DELETE_CHARACTER_COMMAND, false);
     }
-  } else if (isDeleteWordBackward(key, altKey, ctrlKey)) {
+  } else if (isDeleteWordBackward(event)) {
     event.preventDefault();
     dispatchCommand(editor, DELETE_WORD_COMMAND, true);
-  } else if (isDeleteWordForward(key, altKey, ctrlKey)) {
+  } else if (isDeleteWordForward(event)) {
     event.preventDefault();
     dispatchCommand(editor, DELETE_WORD_COMMAND, false);
-  } else if (isDeleteLineBackward(key, metaKey)) {
+  } else if (isDeleteLineBackward(event)) {
     event.preventDefault();
     dispatchCommand(editor, DELETE_LINE_COMMAND, true);
-  } else if (isDeleteLineForward(key, metaKey, ctrlKey)) {
+  } else if (isDeleteLineForward(event)) {
     event.preventDefault();
     dispatchCommand(editor, DELETE_LINE_COMMAND, false);
-  } else if (isBold(key, altKey, metaKey, ctrlKey)) {
+  } else if (isBold(event)) {
     event.preventDefault();
     dispatchCommand(editor, FORMAT_TEXT_COMMAND, 'bold');
-  } else if (isUnderline(key, altKey, metaKey, ctrlKey)) {
+  } else if (isUnderline(event)) {
     event.preventDefault();
     dispatchCommand(editor, FORMAT_TEXT_COMMAND, 'underline');
-  } else if (isItalic(key, altKey, metaKey, ctrlKey)) {
+  } else if (isItalic(event)) {
     event.preventDefault();
     dispatchCommand(editor, FORMAT_TEXT_COMMAND, 'italic');
-  } else if (isTab(key, altKey, ctrlKey, metaKey)) {
+  } else if (isTab(event)) {
     dispatchCommand(editor, KEY_TAB_COMMAND, event);
-  } else if (isUndo(key, shiftKey, metaKey, ctrlKey)) {
+  } else if (isUndo(event)) {
     event.preventDefault();
     dispatchCommand(editor, UNDO_COMMAND, undefined);
-  } else if (isRedo(key, shiftKey, metaKey, ctrlKey)) {
+  } else if (isRedo(event)) {
     event.preventDefault();
     dispatchCommand(editor, REDO_COMMAND, undefined);
   } else {
     const prevSelection = editor._editorState._selection;
     if (prevSelection !== null && !$isRangeSelection(prevSelection)) {
       // Only RangeSelection can use the native cut/copy/select all
-      if (isCopy(key, shiftKey, metaKey, ctrlKey)) {
+      if (isCopy(event)) {
         event.preventDefault();
         dispatchCommand(editor, COPY_COMMAND, event);
-      } else if (isCut(key, shiftKey, metaKey, ctrlKey)) {
+      } else if (isCut(event)) {
         event.preventDefault();
         dispatchCommand(editor, CUT_COMMAND, event);
-      } else if (isSelectAll(key, metaKey, ctrlKey)) {
+      } else if (isSelectAll(event)) {
         event.preventDefault();
         dispatchCommand(editor, SELECT_ALL_COMMAND, event);
       }
-      // FF does it well (no need to override behavior)
-    } else if (!IS_FIREFOX && isSelectAll(key, metaKey, ctrlKey)) {
+    } else if (!IS_FIREFOX && isSelectAll(event)) {
       event.preventDefault();
       dispatchCommand(editor, SELECT_ALL_COMMAND, event);
     }
   }
-  if (isModifier(ctrlKey, shiftKey, altKey, metaKey)) {
+  if (isModifier(event)) {
     dispatchCommand(editor, KEY_MODIFIER_COMMAND, event);
   }
 }
@@ -10355,7 +10438,7 @@ class LexicalEditor {
     };
   }
 }
-LexicalEditor.version = "0.30.1-nightly.20250414.0+dev.cjs";
+LexicalEditor.version = "0.30.1-nightly.20250416.0+dev.cjs";
 
 let keyCounter = 1;
 function resetRandomKey() {
@@ -10546,6 +10629,13 @@ function internalMarkParentElementsAsDirty(parentKey, nodeMap, dirtyElements) {
 }
 
 // TODO #6031 this function or their callers have to adjust selection (i.e. insertBefore)
+/**
+ * Removes a node from its parent, updating all necessary pointers and links.
+ * @internal
+ *
+ * This function is for internal use of the library.
+ * Please do not use it as it may change in the future.
+ */
 function removeFromParent(node) {
   const oldParent = node.getParent();
   if (oldParent !== null) {
@@ -10553,47 +10643,38 @@ function removeFromParent(node) {
     const writableParent = oldParent.getWritable();
     const prevSibling = node.getPreviousSibling();
     const nextSibling = node.getNextSibling();
-    // TODO: this function duplicates a bunch of operations, can be simplified.
+
+    // Store sibling keys
+    const nextSiblingKey = nextSibling !== null ? nextSibling.__key : null;
+    const prevSiblingKey = prevSibling !== null ? prevSibling.__key : null;
+
+    // Get writable siblings once
+    const writablePrevSibling = prevSibling !== null ? prevSibling.getWritable() : null;
+    const writableNextSibling = nextSibling !== null ? nextSibling.getWritable() : null;
+
+    // Update parent's first/last pointers
     if (prevSibling === null) {
-      if (nextSibling !== null) {
-        const writableNextSibling = nextSibling.getWritable();
-        writableParent.__first = nextSibling.__key;
-        writableNextSibling.__prev = null;
-      } else {
-        writableParent.__first = null;
-      }
-    } else {
-      const writablePrevSibling = prevSibling.getWritable();
-      if (nextSibling !== null) {
-        const writableNextSibling = nextSibling.getWritable();
-        writableNextSibling.__prev = writablePrevSibling.__key;
-        writablePrevSibling.__next = writableNextSibling.__key;
-      } else {
-        writablePrevSibling.__next = null;
-      }
-      writableNode.__prev = null;
+      writableParent.__first = nextSiblingKey;
     }
     if (nextSibling === null) {
-      if (prevSibling !== null) {
-        const writablePrevSibling = prevSibling.getWritable();
-        writableParent.__last = prevSibling.__key;
-        writablePrevSibling.__next = null;
-      } else {
-        writableParent.__last = null;
-      }
-    } else {
-      const writableNextSibling = nextSibling.getWritable();
-      if (prevSibling !== null) {
-        const writablePrevSibling = prevSibling.getWritable();
-        writablePrevSibling.__next = writableNextSibling.__key;
-        writableNextSibling.__prev = writablePrevSibling.__key;
-      } else {
-        writableNextSibling.__prev = null;
-      }
-      writableNode.__next = null;
+      writableParent.__last = prevSiblingKey;
     }
-    writableParent.__size--;
+
+    // Update sibling links
+    if (writablePrevSibling !== null) {
+      writablePrevSibling.__next = nextSiblingKey;
+    }
+    if (writableNextSibling !== null) {
+      writableNextSibling.__prev = prevSiblingKey;
+    }
+
+    // Clear node's links
+    writableNode.__prev = null;
+    writableNode.__next = null;
     writableNode.__parent = null;
+
+    // Update parent size
+    writableParent.__size--;
   }
 }
 
@@ -10919,150 +11000,184 @@ function $shouldInsertTextAfterOrBeforeTextNode(selection, node) {
     return false;
   }
 }
-function isTab(key, altKey, ctrlKey, metaKey) {
-  return key === 'Tab' && !altKey && !ctrlKey && !metaKey;
+
+/**
+ * A KeyboardEvent or structurally similar object with a string `key` as well
+ * as `altKey`, `ctrlKey`, `metaKey`, and `shiftKey` boolean properties.
+ */
+
+/**
+ * A record of keyboard modifiers that must be enabled.
+ * If the value is `'any'` then the modifier key's state is ignored.
+ * If the value is `true` then the modifier key must be pressed.
+ * If the value is `false` or the property is omitted then the modifier key must
+ * not be pressed.
+ */
+
+function matchModifier(event, mask, prop) {
+  const expected = mask[prop] || false;
+  return expected === 'any' || expected === event[prop];
 }
-function isBold(key, altKey, metaKey, ctrlKey) {
-  return key.toLowerCase() === 'b' && !altKey && controlOrMeta(metaKey, ctrlKey);
+
+/**
+ * Match a KeyboardEvent with its expected modifier state
+ *
+ * @param event A KeyboardEvent, or structurally similar object
+ * @param mask An object specifying the expected state of the modifiers
+ * @returns true if the event matches
+ */
+function isModifierMatch(event, mask) {
+  return matchModifier(event, mask, 'altKey') && matchModifier(event, mask, 'ctrlKey') && matchModifier(event, mask, 'shiftKey') && matchModifier(event, mask, 'metaKey');
 }
-function isItalic(key, altKey, metaKey, ctrlKey) {
-  return key.toLowerCase() === 'i' && !altKey && controlOrMeta(metaKey, ctrlKey);
+
+/**
+ * Match a KeyboardEvent with its expected state
+ *
+ * @param event A KeyboardEvent, or structurally similar object
+ * @param expectedKey The string to compare with event.key (case insensitive)
+ * @param mask An object specifying the expected state of the modifiers
+ * @returns true if the event matches
+ */
+function isExactShortcutMatch(event, expectedKey, mask) {
+  return isModifierMatch(event, mask) && event.key.toLowerCase() === expectedKey.toLowerCase();
 }
-function isUnderline(key, altKey, metaKey, ctrlKey) {
-  return key.toLowerCase() === 'u' && !altKey && controlOrMeta(metaKey, ctrlKey);
+const CONTROL_OR_META = {
+  ctrlKey: !IS_APPLE,
+  metaKey: IS_APPLE
+};
+const CONTROL_OR_ALT = {
+  altKey: IS_APPLE,
+  ctrlKey: !IS_APPLE
+};
+function isTab(event) {
+  return isExactShortcutMatch(event, 'Tab', {
+    shiftKey: 'any'
+  });
 }
-function isParagraph(key, shiftKey) {
-  return isReturn(key) && !shiftKey;
+function isBold(event) {
+  return isExactShortcutMatch(event, 'b', CONTROL_OR_META);
 }
-function isLineBreak(key, shiftKey) {
-  return isReturn(key) && shiftKey;
+function isItalic(event) {
+  return isExactShortcutMatch(event, 'i', CONTROL_OR_META);
+}
+function isUnderline(event) {
+  return isExactShortcutMatch(event, 'u', CONTROL_OR_META);
+}
+function isParagraph(event) {
+  return isExactShortcutMatch(event, 'Enter', {});
+}
+function isLineBreak(event) {
+  return isExactShortcutMatch(event, 'Enter', {
+    shiftKey: true
+  });
 }
 
 // Inserts a new line after the selection
 
-function isOpenLineBreak(key, ctrlKey) {
+function isOpenLineBreak(event) {
   // 79 = KeyO
-  return IS_APPLE && ctrlKey && key.toLowerCase() === 'o';
-}
-function isDeleteWordBackward(key, altKey, ctrlKey) {
-  return isBackspace(key) && (IS_APPLE ? altKey : ctrlKey);
+  return IS_APPLE && isExactShortcutMatch(event, 'o', {
+    ctrlKey: true
+  });
 }
-function isDeleteWordForward(key, altKey, ctrlKey) {
-  return isDelete(key) && (IS_APPLE ? altKey : ctrlKey);
+function isDeleteWordBackward(event) {
+  return isExactShortcutMatch(event, 'Backspace', CONTROL_OR_ALT);
 }
-function isDeleteLineBackward(key, metaKey) {
-  return IS_APPLE && metaKey && isBackspace(key);
+function isDeleteWordForward(event) {
+  return isExactShortcutMatch(event, 'Delete', CONTROL_OR_ALT);
 }
-function isDeleteLineForward(key, metaKey, ctrlKey) {
-  return IS_APPLE && (metaKey && isDelete(key) || ctrlKey && key.toLowerCase() === 'k');
+function isDeleteLineBackward(event) {
+  return IS_APPLE && isExactShortcutMatch(event, 'Backspace', {
+    metaKey: true
+  });
 }
-function isDeleteBackward(key, altKey, metaKey, ctrlKey) {
-  if (IS_APPLE) {
-    if (altKey || metaKey) {
-      return false;
-    }
-    return isBackspace(key) || key.toLowerCase() === 'h' && ctrlKey;
-  }
-  if (ctrlKey || altKey || metaKey) {
-    return false;
-  }
-  return isBackspace(key);
+function isDeleteLineForward(event) {
+  return IS_APPLE && (isExactShortcutMatch(event, 'Delete', {
+    metaKey: true
+  }) || isExactShortcutMatch(event, 'k', {
+    ctrlKey: true
+  }));
+}
+function isDeleteBackward(event) {
+  return isExactShortcutMatch(event, 'Backspace', {
+    shiftKey: 'any'
+  }) || IS_APPLE && isExactShortcutMatch(event, 'h', {
+    ctrlKey: true
+  });
 }
-function isDeleteForward(key, ctrlKey, shiftKey, altKey, metaKey) {
-  if (IS_APPLE) {
-    if (shiftKey || altKey || metaKey) {
-      return false;
-    }
-    return isDelete(key) || key.toLowerCase() === 'd' && ctrlKey;
-  }
-  if (ctrlKey || altKey || metaKey) {
-    return false;
-  }
-  return isDelete(key);
+function isDeleteForward(event) {
+  return isExactShortcutMatch(event, 'Delete', {}) || IS_APPLE && isExactShortcutMatch(event, 'd', {
+    ctrlKey: true
+  });
 }
-function isUndo(key, shiftKey, metaKey, ctrlKey) {
-  return key.toLowerCase() === 'z' && !shiftKey && controlOrMeta(metaKey, ctrlKey);
+function isUndo(event) {
+  return isExactShortcutMatch(event, 'z', CONTROL_OR_META);
 }
-function isRedo(key, shiftKey, metaKey, ctrlKey) {
+function isRedo(event) {
   if (IS_APPLE) {
-    return key.toLowerCase() === 'z' && metaKey && shiftKey;
-  }
-  return key.toLowerCase() === 'y' && ctrlKey || key.toLowerCase() === 'z' && ctrlKey && shiftKey;
-}
-function isCopy(key, shiftKey, metaKey, ctrlKey) {
-  if (shiftKey) {
-    return false;
-  }
-  if (key.toLowerCase() === 'c') {
-    return IS_APPLE ? metaKey : ctrlKey;
-  }
-  return false;
-}
-function isCut(key, shiftKey, metaKey, ctrlKey) {
-  if (shiftKey) {
-    return false;
-  }
-  if (key.toLowerCase() === 'x') {
-    return IS_APPLE ? metaKey : ctrlKey;
+    return isExactShortcutMatch(event, 'z', {
+      metaKey: true,
+      shiftKey: true
+    });
   }
-  return false;
-}
-function isArrowLeft(key) {
-  return key === 'ArrowLeft';
-}
-function isArrowRight(key) {
-  return key === 'ArrowRight';
-}
-function isArrowUp(key) {
-  return key === 'ArrowUp';
-}
-function isArrowDown(key) {
-  return key === 'ArrowDown';
+  return isExactShortcutMatch(event, 'y', {
+    ctrlKey: true
+  }) || isExactShortcutMatch(event, 'z', {
+    ctrlKey: true,
+    shiftKey: true
+  });
 }
-function isMoveBackward(key, ctrlKey, altKey, metaKey) {
-  return isArrowLeft(key) && !ctrlKey && !metaKey && !altKey;
+function isCopy(event) {
+  return isExactShortcutMatch(event, 'c', CONTROL_OR_META);
 }
-function isMoveToStart(key, ctrlKey, shiftKey, altKey, metaKey) {
-  return isArrowLeft(key) && !altKey && !shiftKey && (ctrlKey || metaKey);
+function isCut(event) {
+  return isExactShortcutMatch(event, 'x', CONTROL_OR_META);
 }
-function isMoveForward(key, ctrlKey, altKey, metaKey) {
-  return isArrowRight(key) && !ctrlKey && !metaKey && !altKey;
+function isMoveBackward(event) {
+  return isExactShortcutMatch(event, 'ArrowLeft', {
+    shiftKey: 'any'
+  });
 }
-function isMoveToEnd(key, ctrlKey, shiftKey, altKey, metaKey) {
-  return isArrowRight(key) && !altKey && !shiftKey && (ctrlKey || metaKey);
+function isMoveToStart(event) {
+  return isExactShortcutMatch(event, 'ArrowLeft', CONTROL_OR_META);
 }
-function isMoveUp(key, ctrlKey, metaKey) {
-  return isArrowUp(key) && !ctrlKey && !metaKey;
+function isMoveForward(event) {
+  return isExactShortcutMatch(event, 'ArrowRight', {
+    shiftKey: 'any'
+  });
 }
-function isMoveDown(key, ctrlKey, metaKey) {
-  return isArrowDown(key) && !ctrlKey && !metaKey;
+function isMoveToEnd(event) {
+  return isExactShortcutMatch(event, 'ArrowRight', CONTROL_OR_META);
 }
-function isModifier(ctrlKey, shiftKey, altKey, metaKey) {
-  return ctrlKey || shiftKey || altKey || metaKey;
+function isMoveUp(event) {
+  return isExactShortcutMatch(event, 'ArrowUp', {
+    altKey: 'any',
+    shiftKey: 'any'
+  });
 }
-function isSpace(key) {
-  return key === ' ';
+function isMoveDown(event) {
+  return isExactShortcutMatch(event, 'ArrowDown', {
+    altKey: 'any',
+    shiftKey: 'any'
+  });
 }
-function controlOrMeta(metaKey, ctrlKey) {
-  if (IS_APPLE) {
-    return metaKey;
-  }
-  return ctrlKey;
+function isModifier(event) {
+  return event.ctrlKey || event.shiftKey || event.altKey || event.metaKey;
 }
-function isReturn(key) {
-  return key === 'Enter';
+function isSpace(event) {
+  return event.key === ' ';
 }
-function isBackspace(key) {
-  return key === 'Backspace';
+function isBackspace(event) {
+  return event.key === 'Backspace';
 }
-function isEscape(key) {
-  return key === 'Escape';
+function isEscape(event) {
+  return event.key === 'Escape';
 }
-function isDelete(key) {
-  return key === 'Delete';
+function isDelete(event) {
+  return event.key === 'Delete';
 }
-function isSelectAll(key, metaKey, ctrlKey) {
-  return key.toLowerCase() === 'a' && controlOrMeta(metaKey, ctrlKey);
+function isSelectAll(event) {
+  return isExactShortcutMatch(event, 'a', CONTROL_OR_META);
 }
 function $selectAll(selection) {
   const root = $getRoot();
@@ -13242,13 +13357,16 @@ exports.isDOMNode = isDOMNode;
 exports.isDOMTextNode = isDOMTextNode;
 exports.isDOMUnmanaged = isDOMUnmanaged;
 exports.isDocumentFragment = isDocumentFragment;
+exports.isExactShortcutMatch = isExactShortcutMatch;
 exports.isHTMLAnchorElement = isHTMLAnchorElement;
 exports.isHTMLElement = isHTMLElement;
 exports.isInlineDomNode = isInlineDomNode;
 exports.isLexicalEditor = isLexicalEditor;
+exports.isModifierMatch = isModifierMatch;
 exports.isSelectionCapturedInDecoratorInput = isSelectionCapturedInDecoratorInput;
 exports.isSelectionWithinEditor = isSelectionWithinEditor;
 exports.makeStepwiseIterator = makeStepwiseIterator;
+exports.removeFromParent = removeFromParent;
 exports.resetRandomKey = resetRandomKey;
 exports.setDOMUnmanaged = setDOMUnmanaged;
 exports.setNodeIndentFromDOM = setNodeIndentFromDOM;