lexical 0.11.0 → 0.11.2

package/LexicalCommands.d.ts

@@ -6,7 +6,7 @@
  *
  */
 import type { ElementFormatType, LexicalCommand, TextFormatType } from 'lexical';
-export declare type PasteCommandType = ClipboardEvent | InputEvent | KeyboardEvent;
+export type PasteCommandType = ClipboardEvent | InputEvent | KeyboardEvent;
 export declare function createCommand<T>(type?: string): LexicalCommand<T>;
 export declare const SELECTION_CHANGE_COMMAND: LexicalCommand<void>;
 export declare const CLICK_COMMAND: LexicalCommand<MouseEvent>;
@@ -15,7 +15,7 @@ export declare const INSERT_LINE_BREAK_COMMAND: LexicalCommand<boolean>;
 export declare const INSERT_PARAGRAPH_COMMAND: LexicalCommand<void>;
 export declare const CONTROLLED_TEXT_INSERTION_COMMAND: LexicalCommand<InputEvent | string>;
 export declare const PASTE_COMMAND: LexicalCommand<PasteCommandType>;
-export declare const REMOVE_TEXT_COMMAND: LexicalCommand<void>;
+export declare const REMOVE_TEXT_COMMAND: LexicalCommand<InputEvent | null>;
 export declare const DELETE_WORD_COMMAND: LexicalCommand<boolean>;
 export declare const DELETE_LINE_COMMAND: LexicalCommand<boolean>;
 export declare const FORMAT_TEXT_COMMAND: LexicalCommand<TextFormatType>;
@@ -42,8 +42,8 @@ export declare const FORMAT_ELEMENT_COMMAND: LexicalCommand<ElementFormatType>;
 export declare const DRAGSTART_COMMAND: LexicalCommand<DragEvent>;
 export declare const DRAGOVER_COMMAND: LexicalCommand<DragEvent>;
 export declare const DRAGEND_COMMAND: LexicalCommand<DragEvent>;
-export declare const COPY_COMMAND: LexicalCommand<ClipboardEvent | KeyboardEvent>;
-export declare const CUT_COMMAND: LexicalCommand<ClipboardEvent | KeyboardEvent>;
+export declare const COPY_COMMAND: LexicalCommand<ClipboardEvent | KeyboardEvent | null>;
+export declare const CUT_COMMAND: LexicalCommand<ClipboardEvent | KeyboardEvent | null>;
 export declare const CLEAR_EDITOR_COMMAND: LexicalCommand<void>;
 export declare const CLEAR_HISTORY_COMMAND: LexicalCommand<void>;
 export declare const CAN_REDO_COMMAND: LexicalCommand<boolean>;

package/LexicalEditor.d.ts

@@ -8,12 +8,12 @@
 import type { EditorState, SerializedEditorState } from './LexicalEditorState';
 import type { DOMConversion, NodeKey } from './LexicalNode';
 import { LexicalNode } from './LexicalNode';
-export declare type Spread<T1, T2> = Omit<T2, keyof T1> & T1;
-export declare type Klass<T extends LexicalNode> = {
+export type Spread<T1, T2> = Omit<T2, keyof T1> & T1;
+export type Klass<T extends LexicalNode> = {
     new (...args: any[]): T;
 } & Omit<LexicalNode, 'constructor'>;
-export declare type EditorThemeClassName = string;
-export declare type TextNodeThemeClasses = {
+export type EditorThemeClassName = string;
+export type TextNodeThemeClasses = {
     base?: EditorThemeClassName;
     bold?: EditorThemeClassName;
     code?: EditorThemeClassName;
@@ -25,19 +25,19 @@ export declare type TextNodeThemeClasses = {
     underline?: EditorThemeClassName;
     underlineStrikethrough?: EditorThemeClassName;
 };
-export declare type EditorUpdateOptions = {
+export type EditorUpdateOptions = {
     onUpdate?: () => void;
     skipTransforms?: true;
     tag?: string;
     discrete?: true;
 };
-export declare type EditorSetOptions = {
+export type EditorSetOptions = {
     tag?: string;
 };
-export declare type EditorFocusOptions = {
+export type EditorFocusOptions = {
     defaultSelection?: 'rootStart' | 'rootEnd';
 };
-export declare type EditorThemeClasses = {
+export type EditorThemeClasses = {
     blockCursor?: EditorThemeClassName;
     characterLimit?: EditorThemeClassName;
     code?: EditorThemeClassName;
@@ -96,12 +96,12 @@ export declare type EditorThemeClasses = {
     indent?: EditorThemeClassName;
     [key: string]: any;
 };
-export declare type EditorConfig = {
+export type EditorConfig = {
     disableEvents?: boolean;
     namespace: string;
     theme: EditorThemeClasses;
 };
-export declare type CreateEditorArgs = {
+export type CreateEditorArgs = {
     disableEvents?: boolean;
     editorState?: EditorState;
     namespace?: string;
@@ -117,19 +117,19 @@ export declare type CreateEditorArgs = {
     editable?: boolean;
     theme?: EditorThemeClasses;
 };
-export declare type RegisteredNodes = Map<string, RegisteredNode>;
-export declare type RegisteredNode = {
+export type RegisteredNodes = Map<string, RegisteredNode>;
+export type RegisteredNode = {
     klass: Klass<LexicalNode>;
     transforms: Set<Transform<LexicalNode>>;
     replace: null | ((node: LexicalNode) => LexicalNode);
     replaceWithKlass: null | Klass<LexicalNode>;
 };
-export declare type Transform<T extends LexicalNode> = (node: T) => void;
-export declare type ErrorHandler = (error: Error) => void;
-export declare type MutationListeners = Map<MutationListener, Klass<LexicalNode>>;
-export declare type MutatedNodes = Map<Klass<LexicalNode>, Map<NodeKey, NodeMutation>>;
-export declare type NodeMutation = 'created' | 'updated' | 'destroyed';
-export declare type UpdateListener = (arg0: {
+export type Transform<T extends LexicalNode> = (node: T) => void;
+export type ErrorHandler = (error: Error) => void;
+export type MutationListeners = Map<MutationListener, Klass<LexicalNode>>;
+export type MutatedNodes = Map<Klass<LexicalNode>, Map<NodeKey, NodeMutation>>;
+export type NodeMutation = 'created' | 'updated' | 'destroyed';
+export type UpdateListener = (arg0: {
     dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>;
     dirtyLeaves: Set<NodeKey>;
     editorState: EditorState;
@@ -137,22 +137,22 @@ export declare type UpdateListener = (arg0: {
     prevEditorState: EditorState;
     tags: Set<string>;
 }) => void;
-export declare type DecoratorListener<T = never> = (decorator: Record<NodeKey, T>) => void;
-export declare type RootListener = (rootElement: null | HTMLElement, prevRootElement: null | HTMLElement) => void;
-export declare type TextContentListener = (text: string) => void;
-export declare type MutationListener = (nodes: Map<NodeKey, NodeMutation>, payload: {
+export type DecoratorListener<T = never> = (decorator: Record<NodeKey, T>) => void;
+export type RootListener = (rootElement: null | HTMLElement, prevRootElement: null | HTMLElement) => void;
+export type TextContentListener = (text: string) => void;
+export type MutationListener = (nodes: Map<NodeKey, NodeMutation>, payload: {
     updateTags: Set<string>;
     dirtyLeaves: Set<string>;
 }) => void;
-export declare type CommandListener<P> = (payload: P, editor: LexicalEditor) => boolean;
-export declare type EditableListener = (editable: boolean) => void;
-export declare type CommandListenerPriority = 0 | 1 | 2 | 3 | 4;
+export type CommandListener<P> = (payload: P, editor: LexicalEditor) => boolean;
+export type EditableListener = (editable: boolean) => void;
+export type CommandListenerPriority = 0 | 1 | 2 | 3 | 4;
 export declare const COMMAND_PRIORITY_EDITOR = 0;
 export declare const COMMAND_PRIORITY_LOW = 1;
 export declare const COMMAND_PRIORITY_NORMAL = 2;
 export declare const COMMAND_PRIORITY_HIGH = 3;
 export declare const COMMAND_PRIORITY_CRITICAL = 4;
-export declare type LexicalCommand<TPayload> = {
+export type LexicalCommand<TPayload> = {
     type?: string;
 };
 /**
@@ -175,9 +175,9 @@ export declare type LexicalCommand<TPayload> = {
  * }
  * ```
  */
-export declare type CommandPayloadType<TCommand extends LexicalCommand<unknown>> = TCommand extends LexicalCommand<infer TPayload> ? TPayload : never;
-declare type Commands = Map<LexicalCommand<unknown>, Array<Set<CommandListener<unknown>>>>;
-declare type Listeners = {
+export type CommandPayloadType<TCommand extends LexicalCommand<unknown>> = TCommand extends LexicalCommand<infer TPayload> ? TPayload : never;
+type Commands = Map<LexicalCommand<unknown>, Array<Set<CommandListener<unknown>>>>;
+type Listeners = {
     decorator: Set<DecoratorListener>;
     mutation: MutationListeners;
     editable: Set<EditableListener>;
@@ -185,12 +185,12 @@ declare type Listeners = {
     textcontent: Set<TextContentListener>;
     update: Set<UpdateListener>;
 };
-export declare type Listener = DecoratorListener | EditableListener | MutationListener | RootListener | TextContentListener | UpdateListener;
-export declare type ListenerType = 'update' | 'root' | 'decorator' | 'textcontent' | 'mutation' | 'editable';
-export declare type TransformerType = 'text' | 'decorator' | 'element' | 'root';
-declare type IntentionallyMarkedAsDirtyElement = boolean;
-declare type DOMConversionCache = Map<string, Array<(node: Node) => DOMConversion | null>>;
-export declare type SerializedEditor = {
+export type Listener = DecoratorListener | EditableListener | MutationListener | RootListener | TextContentListener | UpdateListener;
+export type ListenerType = 'update' | 'root' | 'decorator' | 'textcontent' | 'mutation' | 'editable';
+export type TransformerType = 'text' | 'decorator' | 'element' | 'root';
+type IntentionallyMarkedAsDirtyElement = boolean;
+type DOMConversionCache = Map<string, Array<(node: Node) => DOMConversion | null>>;
+export type SerializedEditor = {
     editorState: SerializedEditorState;
 };
 export declare function resetEditor(editor: LexicalEditor, prevRootElement: null | HTMLElement, nextRootElement: null | HTMLElement, pendingEditorState: EditorState): void;
@@ -357,6 +357,12 @@ export declare class LexicalEditor {
      * @returns a teardown function that can be used to cleanup the listener.
      */
     registerNodeTransform<T extends LexicalNode>(klass: Klass<T>, listener: Transform<T>): () => void;
+    /**
+     * Used to assert that a certain node is registered, usually by plugins to ensure nodes that they
+     * depend on have been registered.
+     * @returns True if the editor has registered the provided node type, false otherwise.
+     */
+    hasNode<T extends Klass<LexicalNode>>(node: T): boolean;
     /**
      * Used to assert that certain nodes are registered, usually by plugins to ensure nodes that they
      * depend on have been registered.

package/LexicalEvents.d.ts

@@ -7,7 +7,7 @@
  */
 import type { LexicalEditor } from './LexicalEditor';
 import type { NodeKey } from './LexicalNode';
-export declare type EventHandler = (event: Event, editor: LexicalEditor) => void;
+export type EventHandler = (event: Event, editor: LexicalEditor) => void;
 export declare function addRootElementEvents(rootElement: HTMLElement, editor: LexicalEditor): void;
 export declare function removeRootElementEvents(rootElement: HTMLElement): void;
 export declare function markSelectionChangeFromDOMUpdate(): void;

package/LexicalGC.d.ts

@@ -9,6 +9,6 @@ import type { LexicalEditor } from './LexicalEditor';
 import type { EditorState } from './LexicalEditorState';
 import type { NodeKey } from './LexicalNode';
 export declare function $garbageCollectDetachedDecorators(editor: LexicalEditor, pendingEditorState: EditorState): void;
-declare type IntentionallyMarkedAsDirtyElement = boolean;
+type IntentionallyMarkedAsDirtyElement = boolean;
 export declare function $garbageCollectDetachedNodes(prevEditorState: EditorState, editorState: EditorState, dirtyLeaves: Set<NodeKey>, dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>): void;
 export {};

package/LexicalNode.d.ts

@@ -8,30 +8,30 @@
 import type { EditorConfig, LexicalEditor } from './LexicalEditor';
 import type { GridSelection, NodeSelection, RangeSelection } from './LexicalSelection';
 import { ElementNode } from '.';
-export declare type NodeMap = Map<NodeKey, LexicalNode>;
-export declare type SerializedLexicalNode = {
+export type NodeMap = Map<NodeKey, LexicalNode>;
+export type SerializedLexicalNode = {
     type: string;
     version: number;
 };
 export declare function removeNode(nodeToRemove: LexicalNode, restoreSelection: boolean, preserveEmptyParent?: boolean): void;
-export declare type DOMConversion<T extends HTMLElement = HTMLElement> = {
+export type DOMConversion<T extends HTMLElement = HTMLElement> = {
     conversion: DOMConversionFn<T>;
     priority: 0 | 1 | 2 | 3 | 4;
 };
-export declare type DOMConversionFn<T extends HTMLElement = HTMLElement> = (element: T) => DOMConversionOutput | null;
-export declare type DOMChildConversion = (lexicalNode: LexicalNode, parentLexicalNode: LexicalNode | null | undefined) => LexicalNode | null | undefined;
-export declare type DOMConversionMap<T extends HTMLElement = HTMLElement> = Record<NodeName, (node: T) => DOMConversion<T> | null>;
-declare type NodeName = string;
-export declare type DOMConversionOutput = {
+export type DOMConversionFn<T extends HTMLElement = HTMLElement> = (element: T) => DOMConversionOutput | null;
+export type DOMChildConversion = (lexicalNode: LexicalNode, parentLexicalNode: LexicalNode | null | undefined) => LexicalNode | null | undefined;
+export type DOMConversionMap<T extends HTMLElement = HTMLElement> = Record<NodeName, (node: T) => DOMConversion<T> | null>;
+type NodeName = string;
+export type DOMConversionOutput = {
     after?: (childLexicalNodes: Array<LexicalNode>) => Array<LexicalNode>;
     forChild?: DOMChildConversion;
     node: null | LexicalNode | Array<LexicalNode>;
 };
-export declare type DOMExportOutput = {
+export type DOMExportOutput = {
     after?: (generatedElement: HTMLElement | null | undefined) => HTMLElement | null | undefined;
     element: HTMLElement | null;
 };
-export declare type NodeKey = string;
+export type NodeKey = string;
 export declare class LexicalNode {
     [x: string]: any;
     /** @internal */

package/LexicalReconciler.d.ts

@@ -8,7 +8,7 @@
 import type { LexicalEditor, MutatedNodes } from './LexicalEditor';
 import type { NodeKey } from './LexicalNode';
 import { EditorState } from './LexicalEditorState';
-declare type IntentionallyMarkedAsDirtyElement = boolean;
+type IntentionallyMarkedAsDirtyElement = boolean;
 export declare function reconcileRoot(prevEditorState: EditorState, nextEditorState: EditorState, editor: LexicalEditor, dirtyType: 0 | 1 | 2, dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>, dirtyLeaves: Set<NodeKey>): MutatedNodes;
 export declare function storeDOMWithKey(key: NodeKey, dom: HTMLElement, editor: LexicalEditor): void;
 export {};

package/LexicalSelection.d.ts

@@ -12,7 +12,7 @@ import type { ElementNode } from './nodes/LexicalElementNode';
 import type { TextFormatType } from './nodes/LexicalTextNode';
 import { DEPRECATED_GridCellNode, DEPRECATED_GridNode, DEPRECATED_GridRowNode, TextNode } from '.';
 import { LexicalNode } from './LexicalNode';
-export declare type TextPointType = {
+export type TextPointType = {
     _selection: RangeSelection | GridSelection;
     getNode: () => TextNode;
     is: (point: PointType) => boolean;
@@ -22,7 +22,7 @@ export declare type TextPointType = {
     set: (key: NodeKey, offset: number, type: 'text' | 'element') => void;
     type: 'text';
 };
-export declare type ElementPointType = {
+export type ElementPointType = {
     _selection: RangeSelection | GridSelection;
     getNode: () => ElementNode;
     is: (point: PointType) => boolean;
@@ -32,13 +32,13 @@ export declare type ElementPointType = {
     set: (key: NodeKey, offset: number, type: 'text' | 'element') => void;
     type: 'element';
 };
-export declare type PointType = TextPointType | ElementPointType;
-export declare type GridMapValueType = {
+export type PointType = TextPointType | ElementPointType;
+export type GridMapValueType = {
     cell: DEPRECATED_GridCellNode;
     startRow: number;
     startColumn: number;
 };
-export declare type GridMapType = Array<Array<GridMapValueType>>;
+export type GridMapType = Array<Array<GridMapValueType>>;
 export declare class Point {
     key: NodeKey;
     offset: number;
@@ -79,7 +79,7 @@ export declare class NodeSelection implements BaseSelection {
     getTextContent(): string;
 }
 export declare function $isRangeSelection(x: unknown): x is RangeSelection;
-export declare type GridSelectionShape = {
+export type GridSelectionShape = {
     fromX: number;
     fromY: number;
     toX: number;
@@ -115,29 +115,171 @@ export declare class RangeSelection implements BaseSelection {
     style: string;
     _cachedNodes: null | Array<LexicalNode>;
     constructor(anchor: PointType, focus: PointType, format: number, style: string);
+    /**
+     * Used to check if the provided selections is equal to this one by value,
+     * inluding anchor, focus, format, and style properties.
+     * @param selection - the Selection to compare this one to.
+     * @returns true if the Selections are equal, false otherwise.
+     */
     is(selection: null | RangeSelection | NodeSelection | GridSelection): boolean;
+    /**
+     * Returns whether the Selection is "backwards", meaning the focus
+     * logically precedes the anchor in the EditorState.
+     * @returns true if the Selection is backwards, false otherwise.
+     */
     isBackward(): boolean;
+    /**
+     * Returns whether the Selection is "collapsed", meaning the anchor and focus are
+     * the same node and have the same offset.
+     *
+     * @returns true if the Selection is collapsed, false otherwise.
+     */
     isCollapsed(): boolean;
+    /**
+     * Gets all the nodes in the Selection. Uses caching to make it generally suitable
+     * for use in hot paths.
+     *
+     * @returns an Array containing all the nodes in the Selection
+     */
     getNodes(): Array<LexicalNode>;
+    /**
+     * Sets this Selection to be of type "text" at the provided anchor and focus values.
+     *
+     * @param anchorNode - the anchor node to set on the Selection
+     * @param anchorOffset - the offset to set on the Selection
+     * @param focusNode - the focus node to set on the Selection
+     * @param focusOffset - the focus offset to set on the Selection
+     */
     setTextNodeRange(anchorNode: TextNode, anchorOffset: number, focusNode: TextNode, focusOffset: number): void;
+    /**
+     * Gets the (plain) text content of all the nodes in the selection.
+     *
+     * @returns a string representing the text content of all the nodes in the Selection
+     */
     getTextContent(): string;
+    /**
+     * Attempts to map a DOM selection range onto this Lexical Selection,
+     * setting the anchor, focus, and type accordingly
+     *
+     * @param range a DOM Selection range conforming to the StaticRange interface.
+     */
     applyDOMRange(range: StaticRange): void;
+    /**
+     * Creates a new RangeSelection, copying over all the property values from this one.
+     *
+     * @returns a new RangeSelection with the same property values as this one.
+     */
     clone(): RangeSelection;
+    /**
+     * Toggles the provided format on all the TextNodes in the Selection.
+     *
+     * @param format a string TextFormatType to toggle on the TextNodes in the selection
+     */
     toggleFormat(format: TextFormatType): void;
+    /**
+     * Sets the value of the style property on the Selection
+     *
+     * @param style - the style to set at the value of the style property.
+     */
     setStyle(style: string): void;
+    /**
+     * Returns whether the provided TextFormatType is present on the Selection. This will be true if any node in the Selection
+     * has the specified format.
+     *
+     * @param type the TextFormatType to check for.
+     * @returns true if the provided format is currently toggled on on the Selection, false otherwise.
+     */
     hasFormat(type: TextFormatType): boolean;
+    /**
+     * Attempts to insert the provided text into the EditorState at the current Selection.
+     * converts tabs, newlines, and carriage returns into LexicalNodes.
+     *
+     * @param text the text to insert into the Selection
+     */
     insertRawText(text: string): void;
+    /**
+     * Attempts to insert the provided text into the EditorState at the current Selection as a new
+     * Lexical TextNode, according to a series of insertion heuristics based on the selection type and position.
+     *
+     * @param text the text to insert into the Selection
+     */
     insertText(text: string): void;
+    /**
+     * Removes the text in the Selection, adjusting the EditorState accordingly.
+     */
     removeText(): void;
+    /**
+     * Applies the provided format to the TextNodes in the Selection, splitting or
+     * merging nodes as necessary.
+     *
+     * @param formatType the format type to apply to the nodes in the Selection.
+     */
     formatText(formatType: TextFormatType): void;
+    /**
+     * Attempts to "intelligently" insert an arbitrary list of Lexical nodes into the EditorState at the
+     * current Selection according to a set of heuristics that determine how surrounding nodes
+     * should be changed, replaced, or moved to accomodate the incoming ones.
+     *
+     * @param nodes - the nodes to insert
+     * @param selectStart - whether or not to select the start after the insertion.
+     * @returns true if the nodes were inserted successfully, false otherwise.
+     */
     insertNodes(nodes: Array<LexicalNode>, selectStart?: boolean): boolean;
+    /**
+     * Inserts a new ParagraphNode into the EditorState at the current Selection
+     */
     insertParagraph(): void;
+    /**
+     * Inserts a logical linebreak, which may be a new LineBreakNode or a new ParagraphNode, into the EditorState at the
+     * current Selection.
+     *
+     * @param selectStart whether or not to select the start of the insertion range after the operation completes.
+     */
     insertLineBreak(selectStart?: boolean): void;
+    /**
+     * Returns the character-based offsets of the Selection, accounting for non-text Points
+     * by using the children size or text content.
+     *
+     * @returns the character offsets for the Selection
+     */
     getCharacterOffsets(): [number, number];
+    /**
+     * Extracts the nodes in the Selection, splitting nodes where necessary
+     * to get offset-level precision.
+     *
+     * @returns The nodes in the Selection
+     */
     extract(): Array<LexicalNode>;
+    /**
+     * Modifies the Selection according to the parameters and a set of heuristics that account for
+     * various node types. Can be used to safely move or extend selection by one logical "unit" without
+     * dealing explicitly with all the possible node types.
+     *
+     * @param alter the type of modification to perform
+     * @param isBackward whether or not selection is backwards
+     * @param granularity the granularity at which to apply the modification
+     */
     modify(alter: 'move' | 'extend', isBackward: boolean, granularity: 'character' | 'word' | 'lineboundary'): void;
+    /**
+     * Performs one logical character deletion operation on the EditorState based on the current Selection.
+     * Handles different node types.
+     *
+     * @param isBackward whether or not the selection is backwards.
+     */
     deleteCharacter(isBackward: boolean): void;
+    /**
+     * Performs one logical line deletion operation on the EditorState based on the current Selection.
+     * Handles different node types.
+     *
+     * @param isBackward whether or not the selection is backwards.
+     */
     deleteLine(isBackward: boolean): void;
+    /**
+     * Performs one logical word deletion operation on the EditorState based on the current Selection.
+     * Handles different node types.
+     *
+     * @param isBackward whether or not the selection is backwards.
+     */
     deleteWord(isBackward: boolean): void;
 }
 export declare function $isNodeSelection(x: unknown): x is NodeSelection;

package/LexicalUpdates.d.ts

@@ -19,7 +19,7 @@ export declare function $applyTransforms(editor: LexicalEditor, node: LexicalNod
 export declare function $parseSerializedNode(serializedNode: SerializedLexicalNode): LexicalNode;
 export declare function parseEditorState(serializedEditorState: SerializedEditorState, editor: LexicalEditor, updateFn: void | (() => void)): EditorState;
 export declare function readEditorState<V>(editorState: EditorState, callbackFn: () => V): V;
-export declare function commitPendingUpdates(editor: LexicalEditor): void;
+export declare function commitPendingUpdates(editor: LexicalEditor, recoveryEditorState?: EditorState): void;
 export declare function triggerListeners(type: 'update' | 'root' | 'decorator' | 'textcontent' | 'editable', editor: LexicalEditor, isCurrentlyEnqueuingUpdates: boolean, ...payload: unknown[]): void;
 export declare function triggerCommandListeners<TCommand extends LexicalCommand<unknown>>(editor: LexicalEditor, type: TCommand, payload: CommandPayloadType<TCommand>): boolean;
 export declare function updateEditor(editor: LexicalEditor, updateFn: () => void, options?: EditorUpdateOptions): void;

package/LexicalUtils.d.ts

@@ -84,6 +84,7 @@ export declare function isBackspace(keyCode: number): boolean;
 export declare function isEscape(keyCode: number): boolean;
 export declare function isDelete(keyCode: number): boolean;
 export declare function isSelectAll(keyCode: number, metaKey: boolean, ctrlKey: boolean): boolean;
+export declare function $selectAll(): void;
 export declare function getCachedClassNameArray(classNamesTheme: EditorThemeClasses, classNameThemeType: string): Array<string>;
 export declare function setMutatedNode(mutatedNodes: MutatedNodes, registeredNodes: RegisteredNodes, mutationListeners: MutationListeners, node: LexicalNode, mutation: NodeMutation): void;
 export declare function $nodesOfType<T extends LexicalNode>(klass: Klass<T>): Array<T>;
@@ -96,7 +97,7 @@ export declare function getParentElement(node: Node): HTMLElement | null;
 export declare function scrollIntoViewIfNeeded(editor: LexicalEditor, selectionRect: DOMRect, rootElement: HTMLElement): void;
 export declare function $hasUpdateTag(tag: string): boolean;
 export declare function $addUpdateTag(tag: string): void;
-export declare function $maybeMoveChildrenSelectionToParent(parentNode: LexicalNode, offset?: number): RangeSelection | NodeSelection | GridSelection | null;
+export declare function $maybeMoveChildrenSelectionToParent(parentNode: LexicalNode): RangeSelection | NodeSelection | GridSelection | null;
 export declare function $hasAncestor(child: LexicalNode, targetNode: LexicalNode): boolean;
 export declare function getDefaultView(domElem: HTMLElement): Window | null;
 export declare function getWindow(editor: LexicalEditor): Window;

package/nodes/LexicalElementNode.d.ts

@@ -10,13 +10,13 @@ import type { GridSelection, NodeSelection, RangeSelection } from '../LexicalSel
 import type { Spread } from 'lexical';
 import { TextNode } from '../';
 import { LexicalNode } from '../LexicalNode';
-export declare type SerializedElementNode<T extends SerializedLexicalNode = SerializedLexicalNode> = Spread<{
+export type SerializedElementNode<T extends SerializedLexicalNode = SerializedLexicalNode> = Spread<{
     children: Array<T>;
     direction: 'ltr' | 'rtl' | null;
     format: ElementFormatType;
     indent: number;
 }, SerializedLexicalNode>;
-export declare type ElementFormatType = 'left' | 'start' | 'center' | 'right' | 'end' | 'justify' | '';
+export type ElementFormatType = 'left' | 'start' | 'center' | 'right' | 'end' | 'justify' | '';
 /** @noInheritDoc */
 export declare class ElementNode extends LexicalNode {
     /** @internal */

package/nodes/LexicalGridCellNode.d.ts

@@ -7,7 +7,7 @@
  */
 import type { LexicalNode, NodeKey, SerializedElementNode, Spread } from 'lexical';
 import { ElementNode } from './LexicalElementNode';
-export declare type SerializedGridCellNode = Spread<{
+export type SerializedGridCellNode = Spread<{
     colSpan?: number;
     rowSpan?: number;
 }, SerializedElementNode>;

package/nodes/LexicalLineBreakNode.d.ts

@@ -7,7 +7,7 @@
  */
 import type { DOMConversionMap, NodeKey, SerializedLexicalNode } from '../LexicalNode';
 import { LexicalNode } from '../LexicalNode';
-export declare type SerializedLineBreakNode = SerializedLexicalNode;
+export type SerializedLineBreakNode = SerializedLexicalNode;
 /** @noInheritDoc */
 export declare class LineBreakNode extends LexicalNode {
     static getType(): string;

package/nodes/LexicalParagraphNode.d.ts

@@ -10,7 +10,7 @@ import type { DOMConversionMap, DOMExportOutput, LexicalNode } from '../LexicalN
 import type { SerializedElementNode } from './LexicalElementNode';
 import type { RangeSelection } from 'lexical';
 import { ElementNode } from './LexicalElementNode';
-export declare type SerializedParagraphNode = SerializedElementNode;
+export type SerializedParagraphNode = SerializedElementNode;
 /** @noInheritDoc */
 export declare class ParagraphNode extends ElementNode {
     static getType(): string;

package/nodes/LexicalRootNode.d.ts

@@ -8,7 +8,7 @@
 import type { LexicalNode, SerializedLexicalNode } from '../LexicalNode';
 import type { SerializedElementNode } from './LexicalElementNode';
 import { ElementNode } from './LexicalElementNode';
-export declare type SerializedRootNode<T extends SerializedLexicalNode = SerializedLexicalNode> = SerializedElementNode<T>;
+export type SerializedRootNode<T extends SerializedLexicalNode = SerializedLexicalNode> = SerializedElementNode<T>;
 /** @noInheritDoc */
 export declare class RootNode extends ElementNode {
     /** @internal */

package/nodes/LexicalTabNode.d.ts

@@ -8,7 +8,7 @@
 import type { DOMConversionMap, NodeKey } from '../LexicalNode';
 import { LexicalNode } from '../LexicalNode';
 import { SerializedTextNode, TextDetailType, TextModeType, TextNode } from './LexicalTextNode';
-export declare type SerializedTabNode = SerializedTextNode;
+export type SerializedTabNode = SerializedTextNode;
 /** @noInheritDoc */
 export declare class TabNode extends TextNode {
     static getType(): string;