@lobehub/editor 4.5.0 → 4.6.1

package/es/editor-kernel/lexical/index.d.ts

@@ -1,368 +0,0 @@
-/**
- * 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.
- *
- */
-export type {
-  BaseCaret,
-  CaretDirection,
-  CaretRange,
-  CaretType,
-  ChildCaret,
-  CommonAncestorResult,
-  CommonAncestorResultAncestor,
-  CommonAncestorResultBranch,
-  CommonAncestorResultDescendant,
-  CommonAncestorResultSame,
-  FlipDirection,
-  NodeCaret,
-  PointCaret,
-  RootMode,
-  SiblingCaret,
-  StepwiseIteratorConfig,
-  TextPointCaret,
-  TextPointCaretSlice,
-  TextPointCaretSliceTuple,
-} from './caret/LexicalCaret';
-export {
-  $comparePointCaretNext,
-  $extendCaretToRange,
-  $getAdjacentChildCaret,
-  $getCaretRange,
-  $getChildCaret,
-  $getChildCaretOrSelf,
-  $getCollapsedCaretRange,
-  $getCommonAncestor,
-  $getCommonAncestorResultBranchOrder,
-  $getSiblingCaret,
-  $getTextNodeOffset,
-  $getTextPointCaret,
-  $getTextPointCaretSlice,
-  $isChildCaret,
-  $isNodeCaret,
-  $isSiblingCaret,
-  $isTextPointCaret,
-  $isTextPointCaretSlice,
-  flipDirection,
-  makeStepwiseIterator,
-} from './caret/LexicalCaret';
-export {
-  $caretFromPoint,
-  $caretRangeFromSelection,
-  $getAdjacentSiblingOrParentSiblingCaret,
-  $getCaretInDirection,
-  $getCaretRangeInDirection,
-  $getChildCaretAtIndex,
-  $isExtendableTextPointCaret,
-  $normalizeCaret,
-  $removeTextFromCaretRange,
-  $rewindSiblingCaret,
-  $setPointFromCaret,
-  $setSelectionFromCaretRange,
-  $splitAtPointCaretNext,
-  $updateRangeSelectionFromCaretRange,
-  type SplitAtPointCaretNextOptions,
-} from './caret/LexicalCaretUtils';
-export {
-  BEFORE_INPUT_COMMAND,
-  BLUR_COMMAND,
-  CAN_REDO_COMMAND,
-  CAN_UNDO_COMMAND,
-  CLEAR_EDITOR_COMMAND,
-  CLEAR_HISTORY_COMMAND,
-  CLICK_COMMAND,
-  COMPOSITION_END_COMMAND,
-  COMPOSITION_START_COMMAND,
-  CONTROLLED_TEXT_INSERTION_COMMAND,
-  COPY_COMMAND,
-  createCommand,
-  CUT_COMMAND,
-  DELETE_CHARACTER_COMMAND,
-  DELETE_LINE_COMMAND,
-  DELETE_WORD_COMMAND,
-  DRAGEND_COMMAND,
-  DRAGOVER_COMMAND,
-  DRAGSTART_COMMAND,
-  DROP_COMMAND,
-  FOCUS_COMMAND,
-  FORMAT_ELEMENT_COMMAND,
-  FORMAT_TEXT_COMMAND,
-  INDENT_CONTENT_COMMAND,
-  INPUT_COMMAND,
-  INSERT_LINE_BREAK_COMMAND,
-  INSERT_PARAGRAPH_COMMAND,
-  INSERT_TAB_COMMAND,
-  KEY_ARROW_DOWN_COMMAND,
-  KEY_ARROW_LEFT_COMMAND,
-  KEY_ARROW_RIGHT_COMMAND,
-  KEY_ARROW_UP_COMMAND,
-  KEY_BACKSPACE_COMMAND,
-  KEY_DELETE_COMMAND,
-  KEY_DOWN_COMMAND,
-  KEY_ENTER_COMMAND,
-  KEY_ESCAPE_COMMAND,
-  KEY_MODIFIER_COMMAND,
-  KEY_SPACE_COMMAND,
-  KEY_TAB_COMMAND,
-  MOVE_TO_END,
-  MOVE_TO_START,
-  OUTDENT_CONTENT_COMMAND,
-  PASTE_COMMAND,
-  type PasteCommandType,
-  REDO_COMMAND,
-  REMOVE_TEXT_COMMAND,
-  SELECT_ALL_COMMAND,
-  SELECTION_CHANGE_COMMAND,
-  SELECTION_INSERT_CLIPBOARD_NODES_COMMAND,
-  UNDO_COMMAND,
-} from './LexicalCommands';
-export {
-  IS_ALL_FORMATTING,
-  IS_BOLD,
-  IS_CODE,
-  IS_HIGHLIGHT,
-  IS_ITALIC,
-  IS_STRIKETHROUGH,
-  IS_SUBSCRIPT,
-  IS_SUPERSCRIPT,
-  IS_UNDERLINE,
-  NODE_STATE_KEY,
-  TEXT_TYPE_TO_FORMAT,
-} from './LexicalConstants';
-export type {
-  CommandListener,
-  CommandListenerPriority,
-  CommandPayloadType,
-  CreateEditorArgs,
-  EditableListener,
-  EditorConfig,
-  EditorSetOptions,
-  EditorThemeClasses,
-  EditorThemeClassName,
-  EditorUpdateOptions,
-  HTMLConfig,
-  Klass,
-  KlassConstructor,
-  LexicalCommand,
-  LexicalEditor,
-  LexicalNodeConfig,
-  LexicalNodeReplacement,
-  MutationListener,
-  NodeMutation,
-  RootListener,
-  SerializedEditor,
-  Spread,
-  Transform,
-  UpdateListener,
-  UpdateListenerPayload,
-} from './LexicalEditor';
-export {
-  COMMAND_PRIORITY_CRITICAL,
-  COMMAND_PRIORITY_EDITOR,
-  COMMAND_PRIORITY_HIGH,
-  COMMAND_PRIORITY_LOW,
-  COMMAND_PRIORITY_NORMAL,
-  createEditor,
-  getTransformSetFromKlass,
-} from './LexicalEditor';
-export type {
-  EditorState,
-  EditorStateReadOptions,
-  SerializedEditorState,
-} from './LexicalEditorState';
-export { $isEditorState } from './LexicalEditorState';
-export type { EventHandler } from './LexicalEvents';
-export type {
-  BaseStaticNodeConfig,
-  DOMChildConversion,
-  DOMConversion,
-  DOMConversionFn,
-  DOMConversionMap,
-  DOMConversionOutput,
-  DOMConversionProp,
-  DOMConversionPropByTagName,
-  DOMConversionTagNameMap,
-  DOMExportOutput,
-  DOMExportOutputMap,
-  LexicalExportJSON,
-  LexicalNode,
-  LexicalUpdateJSON,
-  NodeKey,
-  NodeMap,
-  SerializedLexicalNode,
-  StaticNodeConfig,
-  StaticNodeConfigRecord,
-  StaticNodeConfigValue,
-} from './LexicalNode';
-export { buildImportMap } from './LexicalNode';
-export {
-  $getState,
-  $getStateChange,
-  $getWritableNodeState,
-  $setState,
-  type AnyStateConfig,
-  createSharedNodeState,
-  createState,
-  type NodeStateJSON,
-  type StateConfig,
-  type StateConfigKey,
-  type StateConfigValue,
-  type StateValueConfig,
-  type StateValueOrUpdater,
-  type ValueOrUpdater,
-} from './LexicalNodeState';
-export { $normalizeSelection as $normalizeSelection__EXPERIMENTAL } from './LexicalNormalization';
-export type {
-  BaseSelection,
-  ElementPointType as ElementPoint,
-  NodeSelection,
-  Point,
-  PointType,
-  RangeSelection,
-  TextPointType as TextPoint,
-} from './LexicalSelection';
-export {
-  $createNodeSelection,
-  $createPoint,
-  $createRangeSelection,
-  $createRangeSelectionFromDom,
-  $getCharacterOffsets,
-  $getPreviousSelection,
-  $getSelection,
-  $getTextContent,
-  $insertNodes,
-  $isBlockElementNode,
-  $isNodeSelection,
-  $isRangeSelection,
-} from './LexicalSelection';
-export { $parseSerializedNode, isCurrentlyReadOnlyMode } from './LexicalUpdates';
-export {
-  $addUpdateTag,
-  $applyNodeReplacement,
-  $cloneWithProperties,
-  $cloneWithPropertiesEphemeral,
-  $copyNode,
-  $create,
-  $findMatchingParent,
-  $getAdjacentNode,
-  $getEditor,
-  $getNearestNodeFromDOMNode,
-  $getNearestRootOrShadowRoot,
-  $getNodeByKey,
-  $getNodeByKeyOrThrow,
-  $getNodeFromDOMNode,
-  $getRoot,
-  $hasAncestor,
-  $hasUpdateTag,
-  $isInlineElementOrDecoratorNode,
-  $isLeafNode,
-  $isRootOrShadowRoot,
-  $isTokenOrSegmented,
-  $isTokenOrTab,
-  $nodesOfType,
-  $onUpdate,
-  $selectAll,
-  $setCompositionKey,
-  $setSelection,
-  $splitNode,
-  getDOMOwnerDocument,
-  getDOMSelection,
-  getDOMSelectionFromTarget,
-  getDOMTextNode,
-  getEditorPropertyFromDOMNode,
-  getNearestEditorFromDOMNode,
-  getRegisteredNode,
-  getRegisteredNodeOrThrow,
-  getStaticNodeConfig,
-  getTextDirection,
-  INTERNAL_$isBlock,
-  isBlockDomNode,
-  isDocumentFragment,
-  isDOMDocumentNode,
-  isDOMNode,
-  isDOMTextNode,
-  isDOMUnmanaged,
-  isExactShortcutMatch,
-  isHTMLAnchorElement,
-  isHTMLElement,
-  isInlineDomNode,
-  isLexicalEditor,
-  isModifierMatch,
-  isSelectionCapturedInDecoratorInput,
-  isSelectionWithinEditor,
-  removeFromParent,
-  resetRandomKey,
-  setDOMUnmanaged,
-  setNodeIndentFromDOM,
-} from './LexicalUtils';
-export { ArtificialNode__DO_NOT_USE } from './nodes/ArtificialNode';
-export { $isDecoratorNode, DecoratorNode } from './nodes/LexicalDecoratorNode';
-export type {
-  ElementDOMSlot,
-  ElementFormatType,
-  SerializedElementNode,
-} from './nodes/LexicalElementNode';
-export { $isElementNode, ElementNode } from './nodes/LexicalElementNode';
-export type { SerializedLineBreakNode } from './nodes/LexicalLineBreakNode';
-export {
-  $createLineBreakNode,
-  $isLineBreakNode,
-  LineBreakNode,
-} from './nodes/LexicalLineBreakNode';
-export type { SerializedParagraphNode } from './nodes/LexicalParagraphNode';
-export {
-  $createParagraphNode,
-  $isParagraphNode,
-  ParagraphNode,
-} from './nodes/LexicalParagraphNode';
-export type { SerializedRootNode } from './nodes/LexicalRootNode';
-export { $isRootNode, RootNode } from './nodes/LexicalRootNode';
-export type { SerializedTabNode } from './nodes/LexicalTabNode';
-export { $createTabNode, $isTabNode, TabNode } from './nodes/LexicalTabNode';
-export type { SerializedTextNode, TextFormatType, TextModeType } from './nodes/LexicalTextNode';
-export { $createTextNode, $isTextNode, TextNode } from './nodes/LexicalTextNode';
-export {
-  COLLABORATION_TAG,
-  HISTORIC_TAG,
-  HISTORY_MERGE_TAG,
-  HISTORY_PUSH_TAG,
-  PASTE_TAG,
-  SKIP_COLLAB_TAG,
-  SKIP_DOM_SELECTION_TAG,
-  SKIP_SCROLL_INTO_VIEW_TAG,
-  SKIP_SELECTION_FOCUS_TAG,
-  type UpdateTag,
-} from './LexicalUpdateTags';
-export {
-  type AnyLexicalExtension,
-  type AnyLexicalExtensionArgument,
-  type AnyNormalizedLexicalExtensionArgument,
-  configExtension,
-  type configTypeSymbol,
-  declarePeerDependency,
-  defineExtension,
-  type ExtensionBuildState,
-  type ExtensionConfigBase,
-  type ExtensionInitState,
-  type ExtensionRegisterState,
-  type InitialEditorConfig,
-  type InitialEditorStateType,
-  type initTypeSymbol,
-  type LexicalEditorWithDispose,
-  type LexicalExtension,
-  type LexicalExtensionArgument,
-  type LexicalExtensionConfig,
-  type LexicalExtensionDependency,
-  type LexicalExtensionInit,
-  type LexicalExtensionInternal,
-  type LexicalExtensionName,
-  type LexicalExtensionOutput,
-  type NormalizedLexicalExtensionArgument,
-  type NormalizedPeerDependency,
-  type OutputComponentExtension,
-  type outputTypeSymbol,
-  safeCast,
-  shallowMergeConfig,
-} from './extension-core';

package/es/editor-kernel/lexical/nodes/ArtificialNode.d.ts

@@ -1,16 +0,0 @@
-/**
- * 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.
- *
- */
-import type { EditorConfig } from 'lexical';
-
-import { ElementNode } from './LexicalElementNode';
-
-/** @internal */
-export declare class ArtificialNode__DO_NOT_USE extends ElementNode {
-  static getType(): string;
-  createDOM(config: EditorConfig): HTMLElement;
-}

package/es/editor-kernel/lexical/nodes/LexicalDecoratorNode.d.ts

@@ -1,32 +0,0 @@
-/**
- * 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.
- *
- */
-import type { EditorConfig } from 'lexical';
-
-import type { KlassConstructor, LexicalEditor } from '../LexicalEditor';
-import { LexicalNode } from '../LexicalNode';
-import type { ElementNode } from './LexicalElementNode';
-
-export interface DecoratorNode<T> {
-  getTopLevelElement(): ElementNode | this | null;
-  getTopLevelElementOrThrow(): ElementNode | this;
-}
-/** @noInheritDoc */
-export declare class DecoratorNode<T> extends LexicalNode {
-  /** @internal */
-  ['constructor']: KlassConstructor<typeof DecoratorNode<T>>;
-  /**
-   * The returned value is added to the LexicalEditor._decorators
-   */
-  decorate(editor: LexicalEditor, config: EditorConfig): null | T;
-  isIsolated(): boolean;
-  isInline(): boolean;
-  isKeyboardSelectable(): boolean;
-}
-export declare function $isDecoratorNode<T>(
-  node: LexicalNode | null | undefined,
-): node is DecoratorNode<T>;

package/es/editor-kernel/lexical/nodes/LexicalElementNode.d.ts

@@ -1,235 +0,0 @@
-/**
- * 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.
- *
- */
-import type {
-  KlassConstructor,
-  LexicalEditor,
-  LexicalUpdateJSON,
-  Spread,
-  TextFormatType,
-} from 'lexical';
-
-import type {
-  DOMExportOutput,
-  LexicalPrivateDOM,
-  NodeKey,
-  SerializedLexicalNode,
-} from '../LexicalNode';
-import { LexicalNode } from '../LexicalNode';
-import type { BaseSelection, RangeSelection } from '../LexicalSelection';
-import { TextNode } from '../index';
-
-export type SerializedElementNode<T extends SerializedLexicalNode = SerializedLexicalNode> = Spread<
-  {
-    children: Array<T>;
-    direction: 'ltr' | 'rtl' | null;
-    format: ElementFormatType;
-    indent: number;
-    textFormat?: number;
-    textStyle?: string;
-  },
-  SerializedLexicalNode
->;
-export type ElementFormatType = 'left' | 'start' | 'center' | 'right' | 'end' | 'justify' | '';
-export interface ElementNode {
-  getTopLevelElement(): ElementNode | null;
-  getTopLevelElementOrThrow(): ElementNode;
-}
-/**
- * A utility class for managing the DOM children of an ElementNode
- */
-export declare class ElementDOMSlot<T extends HTMLElement = HTMLElement> {
-  readonly element: T;
-  readonly before: Node | null;
-  readonly after: Node | null;
-  constructor(
-    /** The element returned by createDOM */
-    element: T,
-    /** All managed children will be inserted before this node, if defined */
-    before?: Node | undefined | null,
-    /** All managed children will be inserted after this node, if defined */
-    after?: Node | undefined | null,
-  );
-  /**
-   * Return a new ElementDOMSlot where all managed children will be inserted before this node
-   */
-  withBefore(before: Node | undefined | null): ElementDOMSlot<T>;
-  /**
-   * Return a new ElementDOMSlot where all managed children will be inserted after this node
-   */
-  withAfter(after: Node | undefined | null): ElementDOMSlot<T>;
-  /**
-   * Return a new ElementDOMSlot with an updated root element
-   */
-  withElement<ElementType extends HTMLElement>(element: ElementType): ElementDOMSlot<ElementType>;
-  /**
-   * Insert the given child before this.before and any reconciler managed line break node,
-   * or append it if this.before is not defined
-   */
-  insertChild(dom: Node): this;
-  /**
-   * Remove the managed child from this container, will throw if it was not already there
-   */
-  removeChild(dom: Node): this;
-  /**
-   * Replace managed child prevDom with dom. Will throw if prevDom is not a child
-   *
-   * @param dom The new node to replace prevDom
-   * @param prevDom the node that will be replaced
-   */
-  replaceChild(dom: Node, prevDom: Node): this;
-  /**
-   * Returns the first managed child of this node,
-   * which will either be this.after.nextSibling or this.element.firstChild,
-   * and will never be this.before if it is defined.
-   */
-  getFirstChild(): ChildNode | null;
-  /**
-   * @internal
-   */
-  getManagedLineBreak(): Exclude<LexicalPrivateDOM['__lexicalLineBreak'], undefined>;
-  /** @internal */
-  setManagedLineBreak(lineBreakType: null | 'empty' | 'line-break' | 'decorator'): void;
-  /** @internal */
-  removeManagedLineBreak(): void;
-  /** @internal */
-  insertManagedLineBreak(webkitHack: boolean): void;
-  /**
-   * @internal
-   *
-   * Returns the offset of the first child
-   */
-  getFirstChildOffset(): number;
-  /**
-   * @internal
-   */
-  resolveChildIndex(
-    element: ElementNode,
-    elementDOM: HTMLElement,
-    initialDOM: Node,
-    initialOffset: number,
-  ): [node: ElementNode, idx: number];
-}
-export declare function indexPath(root: HTMLElement, child: Node): number[];
-/** @noInheritDoc */
-export declare class ElementNode extends LexicalNode {
-  /** @internal */
-  ['constructor']: KlassConstructor<typeof ElementNode>;
-  /** @internal */
-  __first: null | NodeKey;
-  /** @internal */
-  __last: null | NodeKey;
-  /** @internal */
-  __size: number;
-  /** @internal */
-  __format: number;
-  /** @internal */
-  __style: string;
-  /** @internal */
-  __indent: number;
-  /** @internal */
-  __dir: 'ltr' | 'rtl' | null;
-  /** @internal */
-  __textFormat: number;
-  /** @internal */
-  __textStyle: string;
-  constructor(key?: NodeKey);
-  afterCloneFrom(prevNode: this): void;
-  getFormat(): number;
-  getFormatType(): ElementFormatType;
-  getStyle(): string;
-  getIndent(): number;
-  getChildren<T extends LexicalNode>(): Array<T>;
-  getChildrenKeys(): Array<NodeKey>;
-  getChildrenSize(): number;
-  isEmpty(): boolean;
-  isDirty(): boolean;
-  isLastChild(): boolean;
-  getAllTextNodes(): Array<TextNode>;
-  getFirstDescendant<T extends LexicalNode>(): null | T;
-  getLastDescendant<T extends LexicalNode>(): null | T;
-  getDescendantByIndex<T extends LexicalNode>(index: number): null | T;
-  getFirstChild<T extends LexicalNode>(): null | T;
-  getFirstChildOrThrow<T extends LexicalNode>(): T;
-  getLastChild<T extends LexicalNode>(): null | T;
-  getLastChildOrThrow<T extends LexicalNode>(): T;
-  getChildAtIndex<T extends LexicalNode>(index: number): null | T;
-  getTextContent(): string;
-  getTextContentSize(): number;
-  getDirection(): 'ltr' | 'rtl' | null;
-  getTextFormat(): number;
-  hasFormat(type: ElementFormatType): boolean;
-  hasTextFormat(type: TextFormatType): boolean;
-  /**
-   * Returns the format flags applied to the node as a 32-bit integer.
-   *
-   * @returns a number representing the TextFormatTypes applied to the node.
-   */
-  getFormatFlags(type: TextFormatType, alignWithFormat: null | number): number;
-  getTextStyle(): string;
-  select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
-  selectStart(): RangeSelection;
-  selectEnd(): RangeSelection;
-  clear(): this;
-  append(...nodesToAppend: LexicalNode[]): this;
-  setDirection(direction: 'ltr' | 'rtl' | null): this;
-  setFormat(type: ElementFormatType): this;
-  setStyle(style: string): this;
-  setTextFormat(type: number): this;
-  setTextStyle(style: string): this;
-  setIndent(indentLevel: number): this;
-  splice(start: number, deleteCount: number, nodesToInsert: Array<LexicalNode>): this;
-  /**
-   * @internal
-   *
-   * An experimental API that an ElementNode can override to control where its
-   * children are inserted into the DOM, this is useful to add a wrapping node
-   * or accessory nodes before or after the children. The root of the node returned
-   * by createDOM must still be exactly one HTMLElement.
-   */
-  getDOMSlot(element: HTMLElement): ElementDOMSlot<HTMLElement>;
-  exportDOM(editor: LexicalEditor): DOMExportOutput;
-  exportJSON(): SerializedElementNode;
-  updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedElementNode>): this;
-  insertNewAfter(selection: RangeSelection, restoreSelection?: boolean): null | LexicalNode;
-  canIndent(): boolean;
-  collapseAtStart(selection: RangeSelection): boolean;
-  excludeFromCopy(destination?: 'clone' | 'html'): boolean;
-  /** @deprecated @internal */
-  canReplaceWith(replacement: LexicalNode): boolean;
-  /** @deprecated @internal */
-  canInsertAfter(node: LexicalNode): boolean;
-  canBeEmpty(): boolean;
-  canInsertTextBefore(): boolean;
-  canInsertTextAfter(): boolean;
-  isInline(): boolean;
-  isShadowRoot(): boolean;
-  /** @deprecated @internal */
-  canMergeWith(node: ElementNode): boolean;
-  extractWithChild(
-    child: LexicalNode,
-    selection: BaseSelection | null,
-    destination: 'clone' | 'html',
-  ): boolean;
-  /**
-   * Determines whether this node, when empty, can merge with a first block
-   * of nodes being inserted.
-   *
-   * This method is specifically called in {@link RangeSelection.insertNodes}
-   * to determine merging behavior during nodes insertion.
-   *
-   * @example
-   * // In a ListItemNode or QuoteNode implementation:
-   * canMergeWhenEmpty(): true {
-   *  return true;
-   * }
-   */
-  canMergeWhenEmpty(): boolean;
-  /** @internal */
-  reconcileObservedMutation(dom: HTMLElement, editor: LexicalEditor): void;
-}
-export declare function $isElementNode(node: LexicalNode | null | undefined): node is ElementNode;

package/es/editor-kernel/lexical/nodes/LexicalLineBreakNode.d.ts

@@ -1,30 +0,0 @@
-/**
- * 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.
- *
- */
-import type { KlassConstructor } from '../LexicalEditor';
-import type { DOMConversionMap, NodeKey, SerializedLexicalNode } from '../LexicalNode';
-import { LexicalNode } from '../LexicalNode';
-
-export type SerializedLineBreakNode = SerializedLexicalNode;
-/** @noInheritDoc */
-export declare class LineBreakNode extends LexicalNode {
-  /** @internal */
-  ['constructor']: KlassConstructor<typeof LineBreakNode>;
-  static getType(): string;
-  static clone(node: LineBreakNode): LineBreakNode;
-  constructor(key?: NodeKey);
-  getTextContent(): '\n';
-  createDOM(): HTMLElement;
-  updateDOM(): false;
-  isInline(): true;
-  static importDOM(): DOMConversionMap | null;
-  static importJSON(serializedLineBreakNode: SerializedLineBreakNode): LineBreakNode;
-}
-export declare function $createLineBreakNode(): LineBreakNode;
-export declare function $isLineBreakNode(
-  node: LexicalNode | null | undefined,
-): node is LineBreakNode;