@nexo-labs/payload-lexical-blocks-builder 1.0.1 → 1.3.0

package/dist/LexicalDecoratorNode-C9hMKfgk.d.mts

@@ -0,0 +1,2241 @@
+//#region ../../node_modules/.pnpm/lexical@0.35.0/node_modules/lexical/nodes/LexicalElementNode.d.ts
+
+type SerializedElementNode<T extends SerializedLexicalNode = SerializedLexicalNode> = Spread<{
+  children: Array<T>;
+  direction: 'ltr' | 'rtl' | null;
+  format: ElementFormatType;
+  indent: number;
+  textFormat?: number;
+  textStyle?: string;
+}, SerializedLexicalNode>;
+type ElementFormatType = 'left' | 'start' | 'center' | 'right' | 'end' | 'justify' | '';
+interface ElementNode {
+  getTopLevelElement(): ElementNode | null;
+  getTopLevelElementOrThrow(): ElementNode;
+}
+/**
+ * A utility class for managing the DOM children of an ElementNode
+ */
+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];
+}
+/** @noInheritDoc */
+declare class ElementNode extends LexicalNode {
+  ['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;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lexical@0.35.0/node_modules/lexical/nodes/LexicalTextNode.d.ts
+type SerializedTextNode = Spread<{
+  detail: number;
+  format: number;
+  mode: TextModeType;
+  style: string;
+  text: string;
+}, SerializedLexicalNode>;
+type TextDetailType = 'directionless' | 'unmergable';
+type TextFormatType = 'bold' | 'underline' | 'strikethrough' | 'italic' | 'highlight' | 'code' | 'subscript' | 'superscript' | 'lowercase' | 'uppercase' | 'capitalize';
+type TextModeType = 'normal' | 'token' | 'segmented';
+interface TextNode {
+  getTopLevelElement(): ElementNode | null;
+  getTopLevelElementOrThrow(): ElementNode;
+}
+/** @noInheritDoc */
+declare class TextNode extends LexicalNode {
+  ['constructor']: KlassConstructor<typeof TextNode>;
+  __text: string;
+  /** @internal */
+  __format: number;
+  /** @internal */
+  __style: string;
+  /** @internal */
+  __mode: 0 | 1 | 2 | 3;
+  /** @internal */
+  __detail: number;
+  static getType(): string;
+  static clone(node: TextNode): TextNode;
+  afterCloneFrom(prevNode: this): void;
+  constructor(text?: string, key?: NodeKey);
+  /**
+   * Returns a 32-bit integer that represents the TextFormatTypes currently applied to the
+   * TextNode. You probably don't want to use this method directly - consider using TextNode.hasFormat instead.
+   *
+   * @returns a number representing the format of the text node.
+   */
+  getFormat(): number;
+  /**
+   * Returns a 32-bit integer that represents the TextDetailTypes currently applied to the
+   * TextNode. You probably don't want to use this method directly - consider using TextNode.isDirectionless
+   * or TextNode.isUnmergeable instead.
+   *
+   * @returns a number representing the detail of the text node.
+   */
+  getDetail(): number;
+  /**
+   * Returns the mode (TextModeType) of the TextNode, which may be "normal", "token", or "segmented"
+   *
+   * @returns TextModeType.
+   */
+  getMode(): TextModeType;
+  /**
+   * Returns the styles currently applied to the node. This is analogous to CSSText in the DOM.
+   *
+   * @returns CSSText-like string of styles applied to the underlying DOM node.
+   */
+  getStyle(): string;
+  /**
+   * Returns whether or not the node is in "token" mode. TextNodes in token mode can be navigated through character-by-character
+   * with a RangeSelection, but are deleted as a single entity (not individually by character).
+   *
+   * @returns true if the node is in token mode, false otherwise.
+   */
+  isToken(): boolean;
+  /**
+   *
+   * @returns true if Lexical detects that an IME or other 3rd-party script is attempting to
+   * mutate the TextNode, false otherwise.
+   */
+  isComposing(): boolean;
+  /**
+   * Returns whether or not the node is in "segmented" mode. TextNodes in segmented mode can be navigated through character-by-character
+   * with a RangeSelection, but are deleted in space-delimited "segments".
+   *
+   * @returns true if the node is in segmented mode, false otherwise.
+   */
+  isSegmented(): boolean;
+  /**
+   * Returns whether or not the node is "directionless". Directionless nodes don't respect changes between RTL and LTR modes.
+   *
+   * @returns true if the node is directionless, false otherwise.
+   */
+  isDirectionless(): boolean;
+  /**
+   * Returns whether or not the node is unmergeable. In some scenarios, Lexical tries to merge
+   * adjacent TextNodes into a single TextNode. If a TextNode is unmergeable, this won't happen.
+   *
+   * @returns true if the node is unmergeable, false otherwise.
+   */
+  isUnmergeable(): boolean;
+  /**
+   * Returns whether or not the node has the provided format applied. Use this with the human-readable TextFormatType
+   * string values to get the format of a TextNode.
+   *
+   * @param type - the TextFormatType to check for.
+   *
+   * @returns true if the node has the provided format, false otherwise.
+   */
+  hasFormat(type: TextFormatType): boolean;
+  /**
+   * Returns whether or not the node is simple text. Simple text is defined as a TextNode that has the string type "text"
+   * (i.e., not a subclass) and has no mode applied to it (i.e., not segmented or token).
+   *
+   * @returns true if the node is simple text, false otherwise.
+   */
+  isSimpleText(): boolean;
+  /**
+   * Returns the text content of the node as a string.
+   *
+   * @returns a string representing the text content of the node.
+   */
+  getTextContent(): string;
+  /**
+   * 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;
+  /**
+   *
+   * @returns true if the text node supports font styling, false otherwise.
+   */
+  canHaveFormat(): boolean;
+  /**
+   * @returns true if the text node is inline, false otherwise.
+   */
+  isInline(): true;
+  createDOM(config: EditorConfig, editor?: LexicalEditor): HTMLElement;
+  updateDOM(prevNode: this, dom: HTMLElement, config: EditorConfig): boolean;
+  static importDOM(): DOMConversionMap | null;
+  static importJSON(serializedNode: SerializedTextNode): TextNode;
+  updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedTextNode>): this;
+  exportDOM(editor: LexicalEditor): DOMExportOutput;
+  exportJSON(): SerializedTextNode;
+  selectionTransform(prevSelection: null | BaseSelection, nextSelection: RangeSelection): void;
+  /**
+   * Sets the node format to the provided TextFormatType or 32-bit integer. Note that the TextFormatType
+   * version of the argument can only specify one format and doing so will remove all other formats that
+   * may be applied to the node. For toggling behavior, consider using {@link TextNode.toggleFormat}
+   *
+   * @param format - TextFormatType or 32-bit integer representing the node format.
+   *
+   * @returns this TextNode.
+   * // TODO 0.12 This should just be a `string`.
+   */
+  setFormat(format: TextFormatType | number): this;
+  /**
+   * Sets the node detail to the provided TextDetailType or 32-bit integer. Note that the TextDetailType
+   * version of the argument can only specify one detail value and doing so will remove all other detail values that
+   * may be applied to the node. For toggling behavior, consider using {@link TextNode.toggleDirectionless}
+   * or {@link TextNode.toggleUnmergeable}
+   *
+   * @param detail - TextDetailType or 32-bit integer representing the node detail.
+   *
+   * @returns this TextNode.
+   * // TODO 0.12 This should just be a `string`.
+   */
+  setDetail(detail: TextDetailType | number): this;
+  /**
+   * Sets the node style to the provided CSSText-like string. Set this property as you
+   * would an HTMLElement style attribute to apply inline styles to the underlying DOM Element.
+   *
+   * @param style - CSSText to be applied to the underlying HTMLElement.
+   *
+   * @returns this TextNode.
+   */
+  setStyle(style: string): this;
+  /**
+   * Applies the provided format to this TextNode if it's not present. Removes it if it's present.
+   * The subscript and superscript formats are mutually exclusive.
+   * Prefer using this method to turn specific formats on and off.
+   *
+   * @param type - TextFormatType to toggle.
+   *
+   * @returns this TextNode.
+   */
+  toggleFormat(type: TextFormatType): this;
+  /**
+   * Toggles the directionless detail value of the node. Prefer using this method over setDetail.
+   *
+   * @returns this TextNode.
+   */
+  toggleDirectionless(): this;
+  /**
+   * Toggles the unmergeable detail value of the node. Prefer using this method over setDetail.
+   *
+   * @returns this TextNode.
+   */
+  toggleUnmergeable(): this;
+  /**
+   * Sets the mode of the node.
+   *
+   * @returns this TextNode.
+   */
+  setMode(type: TextModeType): this;
+  /**
+   * Sets the text content of the node.
+   *
+   * @param text - the string to set as the text value of the node.
+   *
+   * @returns this TextNode.
+   */
+  setTextContent(text: string): this;
+  /**
+   * Sets the current Lexical selection to be a RangeSelection with anchor and focus on this TextNode at the provided offsets.
+   *
+   * @param _anchorOffset - the offset at which the Selection anchor will be placed.
+   * @param _focusOffset - the offset at which the Selection focus will be placed.
+   *
+   * @returns the new RangeSelection.
+   */
+  select(_anchorOffset?: number, _focusOffset?: number): RangeSelection;
+  selectStart(): RangeSelection;
+  selectEnd(): RangeSelection;
+  /**
+   * Inserts the provided text into this TextNode at the provided offset, deleting the number of characters
+   * specified. Can optionally calculate a new selection after the operation is complete.
+   *
+   * @param offset - the offset at which the splice operation should begin.
+   * @param delCount - the number of characters to delete, starting from the offset.
+   * @param newText - the text to insert into the TextNode at the offset.
+   * @param moveSelection - optional, whether or not to move selection to the end of the inserted substring.
+   *
+   * @returns this TextNode.
+   */
+  spliceText(offset: number, delCount: number, newText: string, moveSelection?: boolean): TextNode;
+  /**
+   * This method is meant to be overridden by TextNode subclasses to control the behavior of those nodes
+   * when a user event would cause text to be inserted before them in the editor. If true, Lexical will attempt
+   * to insert text into this node. If false, it will insert the text in a new sibling node.
+   *
+   * @returns true if text can be inserted before the node, false otherwise.
+   */
+  canInsertTextBefore(): boolean;
+  /**
+   * This method is meant to be overridden by TextNode subclasses to control the behavior of those nodes
+   * when a user event would cause text to be inserted after them in the editor. If true, Lexical will attempt
+   * to insert text into this node. If false, it will insert the text in a new sibling node.
+   *
+   * @returns true if text can be inserted after the node, false otherwise.
+   */
+  canInsertTextAfter(): boolean;
+  /**
+   * Splits this TextNode at the provided character offsets, forming new TextNodes from the substrings
+   * formed by the split, and inserting those new TextNodes into the editor, replacing the one that was split.
+   *
+   * @param splitOffsets - rest param of the text content character offsets at which this node should be split.
+   *
+   * @returns an Array containing the newly-created TextNodes.
+   */
+  splitText(...splitOffsets: Array<number>): Array<TextNode>;
+  /**
+   * Merges the target TextNode into this TextNode, removing the target node.
+   *
+   * @param target - the TextNode to merge into this one.
+   *
+   * @returns this TextNode.
+   */
+  mergeWithSibling(target: TextNode): TextNode;
+  /**
+   * This method is meant to be overridden by TextNode subclasses to control the behavior of those nodes
+   * when used with the registerLexicalTextEntity function. If you're using registerLexicalTextEntity, the
+   * node class that you create and replace matched text with should return true from this method.
+   *
+   * @returns true if the node is to be treated as a "text entity", false otherwise.
+   */
+  isTextEntity(): boolean;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lexical@0.35.0/node_modules/lexical/LexicalSelection.d.ts
+type TextPointType = {
+  _selection: BaseSelection;
+  getNode: () => TextNode;
+  is: (point: PointType) => boolean;
+  isBefore: (point: PointType) => boolean;
+  key: NodeKey;
+  offset: number;
+  set: (key: NodeKey, offset: number, type: 'text' | 'element', onlyIfChanged?: boolean) => void;
+  type: 'text';
+};
+type ElementPointType = {
+  _selection: BaseSelection;
+  getNode: () => ElementNode;
+  is: (point: PointType) => boolean;
+  isBefore: (point: PointType) => boolean;
+  key: NodeKey;
+  offset: number;
+  set: (key: NodeKey, offset: number, type: 'text' | 'element', onlyIfChanged?: boolean) => void;
+  type: 'element';
+};
+type PointType = TextPointType | ElementPointType;
+interface BaseSelection {
+  _cachedNodes: Array<LexicalNode> | null;
+  dirty: boolean;
+  clone(): BaseSelection;
+  extract(): Array<LexicalNode>;
+  getNodes(): Array<LexicalNode>;
+  getTextContent(): string;
+  insertText(text: string): void;
+  insertRawText(text: string): void;
+  is(selection: null | BaseSelection): boolean;
+  insertNodes(nodes: Array<LexicalNode>): void;
+  getStartEndPoints(): null | [PointType, PointType];
+  isCollapsed(): boolean;
+  isBackward(): boolean;
+  getCachedNodes(): LexicalNode[] | null;
+  setCachedNodes(nodes: LexicalNode[] | null): void;
+}
+declare class RangeSelection implements BaseSelection {
+  format: number;
+  style: string;
+  anchor: PointType;
+  focus: PointType;
+  _cachedNodes: Array<LexicalNode> | null;
+  dirty: boolean;
+  constructor(anchor: PointType, focus: PointType, format: number, style: string);
+  getCachedNodes(): LexicalNode[] | null;
+  setCachedNodes(nodes: LexicalNode[] | null): void;
+  /**
+   * Used to check if the provided selections is equal to this one by value,
+   * including 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 | BaseSelection): 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.
+   *
+   * See also the {@link CaretRange} APIs (starting with
+   * {@link $caretRangeFromSelection}), which are likely to provide a better
+   * foundation for any operation where partial selection is relevant
+   * (e.g. the anchor or focus are inside an ElementNode and TextNode)
+   *
+   * @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 format property on the Selection
+   *
+   * @param format - the format to set at the value of the format property.
+   */
+  setFormat(format: number): 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;
+  /**
+   * Insert the provided text into the EditorState at the current Selection.
+   *
+   * @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.
+   * @param alignWithFormat a 32-bit integer representing formatting flags to align with.
+   */
+  formatText(formatType: TextFormatType, alignWithFormat?: number | null): 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 accommodate the incoming ones.
+   *
+   * @param nodes - the nodes to insert
+   */
+  insertNodes(nodes: Array<LexicalNode>): void;
+  /**
+   * Inserts a new ParagraphNode into the EditorState at the current Selection
+   *
+   * @returns the newly inserted node.
+   */
+  insertParagraph(): ElementNode | null;
+  /**
+   * Inserts a logical linebreak, which may be a new LineBreakNode or a new ParagraphNode, into the EditorState at the
+   * current Selection.
+   */
+  insertLineBreak(selectStart?: boolean): void;
+  /**
+   * 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;
+  /**
+   * Helper for handling forward character and word deletion that prevents element nodes
+   * like a table, columns layout being destroyed
+   *
+   * @param anchor the anchor
+   * @param anchorNode the anchor node in the selection
+   * @param isBackward whether or not selection is backwards
+   */
+  forwardDeletion(anchor: PointType, anchorNode: TextNode | ElementNode, isBackward: boolean): boolean;
+  /**
+   * 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;
+  /**
+   * 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;
+  getStartEndPoints(): null | [PointType, PointType];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lexical@0.35.0/node_modules/lexical/nodes/LexicalRootNode.d.ts
+type SerializedRootNode<T extends SerializedLexicalNode = SerializedLexicalNode> = SerializedElementNode<T>;
+//#endregion
+//#region ../../node_modules/.pnpm/lexical@0.35.0/node_modules/lexical/LexicalEditorState.d.ts
+interface SerializedEditorState<T extends SerializedLexicalNode = SerializedLexicalNode> {
+  root: SerializedRootNode<T>;
+}
+interface EditorStateReadOptions {
+  editor?: LexicalEditor | null;
+}
+declare class EditorState {
+  _nodeMap: NodeMap;
+  _selection: null | BaseSelection;
+  _flushSync: boolean;
+  _readOnly: boolean;
+  constructor(nodeMap: NodeMap, selection?: null | BaseSelection);
+  isEmpty(): boolean;
+  read<V$1>(callbackFn: () => V$1, options?: EditorStateReadOptions): V$1;
+  clone(selection?: null | BaseSelection): EditorState;
+  toJSON(): SerializedEditorState;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lexical@0.35.0/node_modules/lexical/LexicalConstants.d.ts
+declare const NODE_STATE_KEY = "$";
+declare const PROTOTYPE_CONFIG_METHOD = "$config";
+//#endregion
+//#region ../../node_modules/.pnpm/lexical@0.35.0/node_modules/lexical/LexicalNodeState.d.ts
+interface NodeStateConfig<S$1 extends AnyStateConfig> {
+  stateConfig: S$1;
+  flat?: boolean;
+}
+type RequiredNodeStateConfig = NodeStateConfig<AnyStateConfig> | AnyStateConfig;
+type StateConfigJSON<S$1> = S$1 extends StateConfig<infer K, infer V> ? { [Key in K]?: V } : Record<never, never>;
+type RequiredNodeStateConfigJSON<Config$1 extends RequiredNodeStateConfig, Flat extends boolean> = StateConfigJSON<Config$1 extends NodeStateConfig<infer S> ? Spread<Config$1, {
+  flat: false;
+}> extends {
+  flat: Flat;
+} ? S : never : false extends Flat ? Config$1 : never>;
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends ((x: infer R) => any) ? R : never;
+type CollectStateJSON<Tuple extends readonly RequiredNodeStateConfig[], Flat extends boolean> = UnionToIntersection<{ [K in keyof Tuple]: RequiredNodeStateConfigJSON<Tuple[K], Flat> }[number]>;
+type GetStaticNodeConfig<T extends LexicalNode> = ReturnType<T[typeof PROTOTYPE_CONFIG_METHOD]> extends infer Record ? Record extends StaticNodeConfigRecord<infer Type, infer Config> ? Config & {
+  readonly type: Type;
+} : never : never;
+type GetStaticNodeConfigs<T extends LexicalNode> = GetStaticNodeConfig<T> extends infer OwnConfig ? OwnConfig extends never ? [] : OwnConfig extends {
+  extends: Klass<infer Parent>;
+} ? GetStaticNodeConfig<Parent> extends infer ParentNodeConfig ? ParentNodeConfig extends never ? [OwnConfig] : [OwnConfig, ...GetStaticNodeConfigs<Parent>] : OwnConfig : [OwnConfig] : [];
+type CollectStateConfigs<Configs> = Configs extends [infer OwnConfig, ...infer ParentConfigs] ? OwnConfig extends {
+  stateConfigs: infer StateConfigs;
+} ? StateConfigs extends readonly RequiredNodeStateConfig[] ? [...StateConfigs, ...CollectStateConfigs<ParentConfigs>] : CollectStateConfigs<ParentConfigs> : CollectStateConfigs<ParentConfigs> : [];
+type GetNodeStateConfig<T extends LexicalNode> = CollectStateConfigs<GetStaticNodeConfigs<T>>;
+/**
+ * The NodeState JSON produced by this LexicalNode
+ */
+type NodeStateJSON<T extends LexicalNode> = Prettify<{
+  [NODE_STATE_KEY]?: Prettify<CollectStateJSON<GetNodeStateConfig<T>, false>>;
+} & CollectStateJSON<GetNodeStateConfig<T>, true>>;
+/**
+ * Configure a value to be used with StateConfig.
+ *
+ * The value type should be inferred from the definition of parse.
+ *
+ * If the value type is not JSON serializable, then unparse must also be provided.
+ *
+ * Values should be treated as immutable, much like React.useState. Mutating
+ * stored values directly will cause unpredictable behavior, is not supported,
+ * and may trigger errors in the future.
+ *
+ * @example
+ * ```ts
+ * const numberOrNullState = createState('numberOrNull', {parse: (v) => typeof v === 'number' ? v : null});
+ * //    ^? State<'numberOrNull', StateValueConfig<number | null>>
+ * const numberState = createState('number', {parse: (v) => typeof v === 'number' ? v : 0});
+ * //    ^? State<'number', StateValueConfig<number>>
+ * ```
+ *
+ * Only the parse option is required, it is generally not useful to
+ * override `unparse` or `isEqual`. However, if you are using
+ * non-primitive types such as Array, Object, Date, or something
+ * more exotic then you would want to override this. In these
+ * cases you might want to reach for third party libraries.
+ *
+ * @example
+ * ```ts
+ * const isoDateState = createState('isoDate', {
+ *   parse: (v): null | Date => {
+ *     const date = typeof v === 'string' ? new Date(v) : null;
+ *     return date && !isNaN(date.valueOf()) ? date : null;
+ *   }
+ *   isEqual: (a, b) => a === b || (a && b && a.valueOf() === b.valueOf()),
+ *   unparse: (v) => v && v.toString()
+ * });
+ * ```
+ *
+ * You may find it easier to write a parse function using libraries like
+ * zod, valibot, ajv, Effect, TypeBox, etc. perhaps with a wrapper function.
+ */
+interface StateValueConfig<V$1> {
+  /**
+   * This function must return a default value when called with undefined,
+   * otherwise it should parse the given JSON value to your type V. Note
+   * that it is not required to copy or clone the given value, you can
+   * pass it directly through if it matches the expected type.
+   *
+   * When you encounter an invalid value, it's up to you to decide
+   * as to whether to ignore it and return the default value,
+   * return some non-default error value, or throw an error.
+   *
+   * It is possible for V to include undefined, but if it does, then
+   * it should also be considered the default value since undefined
+   * can not be serialized to JSON so it is indistinguishable from the
+   * default.
+   *
+   * Similarly, if your V is a function, then usage of {@link $setState}
+   * must use an updater function because your type will be indistinguishable
+   * from an updater function.
+   */
+  parse: (jsonValue: unknown) => V$1;
+  /**
+   * This is optional and for advanced use cases only.
+   *
+   * You may specify a function that converts V back to JSON.
+   * This is mandatory when V is not a JSON serializable type.
+   */
+  unparse?: (parsed: V$1) => unknown;
+  /**
+   * This is optional and for advanced use cases only.
+   *
+   * Used to define the equality function so you can use an Array or Object
+   * as V and still omit default values from the exported JSON.
+   *
+   * The default is `Object.is`, but something like `fast-deep-equal` might be
+   * more appropriate for your use case.
+   */
+  isEqual?: (a: V$1, b: V$1) => boolean;
+}
+/**
+ * The return value of {@link createState}, for use with
+ * {@link $getState} and {@link $setState}.
+ */
+declare class StateConfig<K$1 extends string, V$1> {
+  /** The string key used when serializing this state to JSON */
+  readonly key: K$1;
+  /** The parse function from the StateValueConfig passed to createState */
+  readonly parse: (value?: unknown) => V$1;
+  /**
+   * The unparse function from the StateValueConfig passed to createState,
+   * with a default that is simply a pass-through that assumes the value is
+   * JSON serializable.
+   */
+  readonly unparse: (value: V$1) => unknown;
+  /**
+   * An equality function from the StateValueConfig, with a default of
+   * Object.is.
+   */
+  readonly isEqual: (a: V$1, b: V$1) => boolean;
+  /**
+   * The result of `stateValueConfig.parse(undefined)`, which is computed only
+   * once and used as the default value. When the current value `isEqual` to
+   * the `defaultValue`, it will not be serialized to JSON.
+   */
+  readonly defaultValue: V$1;
+  constructor(key: K$1, stateValueConfig: StateValueConfig<V$1>);
+}
+/**
+ * For advanced use cases, using this type is not recommended unless
+ * it is required (due to TypeScript's lack of features like
+ * higher-kinded types).
+ *
+ * A {@link StateConfig} type with any key and any value that can be
+ * used in situations where the key and value type can not be known,
+ * such as in a generic constraint when working with a collection of
+ * StateConfig.
+ *
+ * {@link StateConfigKey} and {@link StateConfigValue} will be
+ * useful when this is used as a generic constraint.
+ */
+type AnyStateConfig = StateConfig<any, any>;
+/**
+ * @internal
+ *
+ * Opaque state to be stored on the editor's RegisterNode for use by NodeState
+ */
+type SharedNodeState = {
+  sharedConfigMap: SharedConfigMap;
+  flatKeys: Set<string>;
+};
+type KnownStateMap = Map<AnyStateConfig, unknown>;
+type UnknownStateRecord = Record<string, unknown>;
+/**
+ * @internal
+ *
+ * A Map of string keys to state configurations to be shared across nodes
+ * and/or node versions.
+ */
+type SharedConfigMap = Map<string, AnyStateConfig>;
+/**
+ * @internal
+ */
+declare class NodeState<T extends LexicalNode> {
+  /**
+   * @internal
+   *
+   * Track the (versioned) node that this NodeState was created for, to
+   * facilitate copy-on-write for NodeState. When a LexicalNode is cloned,
+   * it will *reference* the NodeState from its prevNode. From the nextNode
+   * you can continue to read state without copying, but the first $setState
+   * will trigger a copy of the prevNode's NodeState with the node property
+   * updated.
+   */
+  readonly node: LexicalNode;
+  /**
+   * @internal
+   *
+   * State that has already been parsed in a get state, so it is safe. (can be returned with
+   * just a cast since the proof was given before).
+   *
+   * Note that it uses StateConfig, so in addition to (1) the CURRENT VALUE, it has access to
+   * (2) the State key (3) the DEFAULT VALUE and (4) the PARSE FUNCTION
+   */
+  readonly knownState: KnownStateMap;
+  /**
+   * @internal
+   *
+   * A copy of serializedNode[NODE_STATE_KEY] that is made when JSON is
+   * imported but has not been parsed yet.
+   *
+   * It stays here until a get state requires us to parse it, and since we
+   * then know the value is safe we move it to knownState.
+   *
+   * Note that since only string keys are used here, we can only allow this
+   * state to pass-through on export or on the next version since there is
+   * no known value configuration. This pass-through is to support scenarios
+   * where multiple versions of the editor code are working in parallel so
+   * an old version of your code doesnt erase metadata that was
+   * set by a newer version of your code.
+   */
+  unknownState: undefined | UnknownStateRecord;
+  /**
+   * @internal
+   *
+   * This sharedNodeState is preserved across all instances of a given
+   * node type in an editor and remains writable. It is how keys are resolved
+   * to configuration.
+   */
+  readonly sharedNodeState: SharedNodeState;
+  /**
+   * @internal
+   *
+   * The count of known or unknown keys in this state, ignoring the
+   * intersection between the two sets.
+   */
+  size: number;
+  /**
+   * @internal
+   */
+  constructor(node: T, sharedNodeState: SharedNodeState, unknownState?: undefined | UnknownStateRecord, knownState?: KnownStateMap, size?: number | undefined);
+  /**
+   * @internal
+   *
+   * Get the value from knownState, or parse it from unknownState
+   * if it contains the given key.
+   *
+   * Updates the sharedConfigMap when no known state is found.
+   * Updates unknownState and knownState when an unknownState is parsed.
+   */
+  getValue<K$1 extends string, V$1>(stateConfig: StateConfig<K$1, V$1>): V$1;
+  /**
+   * @internal
+   *
+   * Used only for advanced use cases, such as collab. The intent here is to
+   * allow you to diff states with a more stable interface than the properties
+   * of this class.
+   */
+  getInternalState(): [{ readonly [k in string]: unknown } | undefined, ReadonlyMap<AnyStateConfig, unknown>];
+  /**
+   * Encode this NodeState to JSON in the format that its node expects.
+   * This returns `{[NODE_STATE_KEY]?: UnknownStateRecord}` rather than
+   * `UnknownStateRecord | undefined` so that we can support flattening
+   * specific entries in the future when nodes can declare what
+   * their required StateConfigs are.
+   */
+  toJSON(): NodeStateJSON<T>;
+  /**
+   * @internal
+   *
+   * A NodeState is writable when the node to update matches
+   * the node associated with the NodeState. This basically
+   * mirrors how the EditorState NodeMap works, but in a
+   * bottom-up organization rather than a top-down organization.
+   *
+   * This allows us to implement the same "copy on write"
+   * pattern for state, without having the state version
+   * update every time the node version changes (e.g. when
+   * its parent or siblings change).
+   *
+   * @param node The node to associate with the state
+   * @returns The next writable state
+   */
+  getWritable(node: T): NodeState<T>;
+  /** @internal */
+  updateFromKnown<K$1 extends string, V$1>(stateConfig: StateConfig<K$1, V$1>, value: V$1): void;
+  /**
+   * @internal
+   *
+   * This is intended for advanced use cases only, such
+   * as collab or dev tools.
+   *
+   * Update a single key value pair from unknown state,
+   * parsing it if the key is known to this node. This is
+   * basically like updateFromJSON, but the effect is
+   * isolated to a single entry.
+   *
+   * @param k The string key from an UnknownStateRecord
+   * @param v The unknown value from an UnknownStateRecord
+   */
+  updateFromUnknown(k: string, v: unknown): void;
+  /**
+   * @internal
+   *
+   * Reset all existing state to default or empty values,
+   * and perform any updates from the given unknownState.
+   *
+   * This is used when initializing a node's state from JSON,
+   * or when resetting a node's state from JSON.
+   *
+   * @param unknownState The new state in serialized form
+   */
+  updateFromJSON(unknownState: undefined | UnknownStateRecord): void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lexical@0.35.0/node_modules/lexical/LexicalUpdateTags.d.ts
+/**
+ * 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.
+ *
+ */
+/**
+ * Common update tags used in Lexical. These tags can be used with editor.update() or $addUpdateTag()
+ * to indicate the type/purpose of an update. Multiple tags can be used in a single update.
+ */
+/**
+ * Indicates that the update is related to history operations (undo/redo)
+ */
+declare const HISTORIC_TAG = "historic";
+/**
+ * Indicates that a new history entry should be pushed to the history stack
+ */
+declare const HISTORY_PUSH_TAG = "history-push";
+/**
+ * Indicates that the current update should be merged with the previous history entry
+ */
+declare const HISTORY_MERGE_TAG = "history-merge";
+/**
+ * Indicates that the update is related to a paste operation
+ */
+declare const PASTE_TAG = "paste";
+/**
+ * Indicates that the update is related to collaborative editing
+ */
+declare const COLLABORATION_TAG = "collaboration";
+/**
+ * Indicates that the update should skip collaborative sync
+ */
+declare const SKIP_COLLAB_TAG = "skip-collab";
+/**
+ * Indicates that the update should skip scrolling the selection into view
+ */
+declare const SKIP_SCROLL_INTO_VIEW_TAG = "skip-scroll-into-view";
+/**
+ * Indicates that the update should skip updating the DOM selection
+ * This is useful when you want to make updates without changing the selection or focus
+ */
+declare const SKIP_DOM_SELECTION_TAG = "skip-dom-selection";
+/**
+ * The update was triggered by editor.focus()
+ */
+declare const FOCUS_TAG = "focus";
+/**
+ * The set of known update tags to help with TypeScript suggestions.
+ */
+type UpdateTag = typeof COLLABORATION_TAG | typeof FOCUS_TAG | typeof HISTORIC_TAG | typeof HISTORY_MERGE_TAG | typeof HISTORY_PUSH_TAG | typeof PASTE_TAG | typeof SKIP_COLLAB_TAG | typeof SKIP_DOM_SELECTION_TAG | typeof SKIP_SCROLL_INTO_VIEW_TAG | (string & {});
+//#endregion
+//#region ../../node_modules/.pnpm/lexical@0.35.0/node_modules/lexical/LexicalEditor.d.ts
+type Spread<T1, T2> = Omit<T2, keyof T1> & T1;
+type KlassConstructor<Cls extends GenericConstructor<any>> = GenericConstructor<InstanceType<Cls>> & { [k in keyof Cls]: Cls[k] };
+type GenericConstructor<T> = new (...args: any[]) => T;
+type Klass<T extends LexicalNode> = InstanceType<T['constructor']> extends T ? T['constructor'] : GenericConstructor<T> & T['constructor'];
+type EditorThemeClassName = string;
+type TextNodeThemeClasses = {
+  base?: EditorThemeClassName;
+  bold?: EditorThemeClassName;
+  code?: EditorThemeClassName;
+  highlight?: EditorThemeClassName;
+  italic?: EditorThemeClassName;
+  lowercase?: EditorThemeClassName;
+  uppercase?: EditorThemeClassName;
+  capitalize?: EditorThemeClassName;
+  strikethrough?: EditorThemeClassName;
+  subscript?: EditorThemeClassName;
+  superscript?: EditorThemeClassName;
+  underline?: EditorThemeClassName;
+  underlineStrikethrough?: EditorThemeClassName;
+  [key: string]: EditorThemeClassName | undefined;
+};
+type EditorUpdateOptions = {
+  /**
+   * A function to run once the update is complete. See also {@link $onUpdate}.
+   */
+  onUpdate?: () => void;
+  /**
+   * Setting this to true will suppress all node
+   * transforms for this update cycle.
+   * Useful for synchronizing updates in some cases.
+   */
+  skipTransforms?: true;
+  /**
+   * A tag to identify this update, in an update listener, for instance.
+   * See also {@link $addUpdateTag}.
+   */
+  tag?: UpdateTag | UpdateTag[];
+  /**
+   * If true, prevents this update from being batched, forcing it to
+   * run synchronously.
+   */
+  discrete?: true;
+  /** @internal */
+  event?: undefined | UIEvent | Event | null;
+};
+type EditorSetOptions = {
+  tag?: string;
+};
+interface EditorFocusOptions {
+  /**
+   * Where to move selection when the editor is
+   * focused. Can be rootStart, rootEnd, or undefined. Defaults to rootEnd.
+   */
+  defaultSelection?: 'rootStart' | 'rootEnd';
+}
+type EditorThemeClasses = {
+  blockCursor?: EditorThemeClassName;
+  characterLimit?: EditorThemeClassName;
+  code?: EditorThemeClassName;
+  codeHighlight?: Record<string, EditorThemeClassName>;
+  hashtag?: EditorThemeClassName;
+  specialText?: EditorThemeClassName;
+  heading?: {
+    h1?: EditorThemeClassName;
+    h2?: EditorThemeClassName;
+    h3?: EditorThemeClassName;
+    h4?: EditorThemeClassName;
+    h5?: EditorThemeClassName;
+    h6?: EditorThemeClassName;
+  };
+  hr?: EditorThemeClassName;
+  hrSelected?: EditorThemeClassName;
+  image?: EditorThemeClassName;
+  link?: EditorThemeClassName;
+  list?: {
+    ul?: EditorThemeClassName;
+    ulDepth?: Array<EditorThemeClassName>;
+    ol?: EditorThemeClassName;
+    olDepth?: Array<EditorThemeClassName>;
+    checklist?: EditorThemeClassName;
+    listitem?: EditorThemeClassName;
+    listitemChecked?: EditorThemeClassName;
+    listitemUnchecked?: EditorThemeClassName;
+    nested?: {
+      list?: EditorThemeClassName;
+      listitem?: EditorThemeClassName;
+    };
+  };
+  ltr?: EditorThemeClassName;
+  mark?: EditorThemeClassName;
+  markOverlap?: EditorThemeClassName;
+  paragraph?: EditorThemeClassName;
+  quote?: EditorThemeClassName;
+  root?: EditorThemeClassName;
+  rtl?: EditorThemeClassName;
+  tab?: EditorThemeClassName;
+  table?: EditorThemeClassName;
+  tableAddColumns?: EditorThemeClassName;
+  tableAddRows?: EditorThemeClassName;
+  tableCellActionButton?: EditorThemeClassName;
+  tableCellActionButtonContainer?: EditorThemeClassName;
+  tableCellSelected?: EditorThemeClassName;
+  tableCell?: EditorThemeClassName;
+  tableCellHeader?: EditorThemeClassName;
+  tableCellResizer?: EditorThemeClassName;
+  tableRow?: EditorThemeClassName;
+  tableScrollableWrapper?: EditorThemeClassName;
+  tableSelected?: EditorThemeClassName;
+  tableSelection?: EditorThemeClassName;
+  text?: TextNodeThemeClasses;
+  embedBlock?: {
+    base?: EditorThemeClassName;
+    focus?: EditorThemeClassName;
+  };
+  indent?: EditorThemeClassName;
+  [key: string]: any;
+};
+type EditorConfig = {
+  disableEvents?: boolean;
+  namespace: string;
+  theme: EditorThemeClasses;
+};
+type LexicalNodeReplacement = {
+  replace: Klass<LexicalNode>;
+  with: <T extends {
+    new (...args: any): any;
+  }>(node: InstanceType<T>) => LexicalNode;
+  withKlass?: Klass<LexicalNode>;
+};
+type HTMLConfig = {
+  export?: DOMExportOutputMap;
+  import?: DOMConversionMap;
+};
+/**
+ * A LexicalNode class or LexicalNodeReplacement configuration
+ */
+type LexicalNodeConfig = Klass<LexicalNode> | LexicalNodeReplacement;
+type CreateEditorArgs = {
+  disableEvents?: boolean;
+  editorState?: EditorState;
+  namespace?: string;
+  nodes?: ReadonlyArray<LexicalNodeConfig>;
+  onError?: ErrorHandler;
+  parentEditor?: LexicalEditor;
+  editable?: boolean;
+  theme?: EditorThemeClasses;
+  html?: HTMLConfig;
+};
+type RegisteredNodes = Map<string, RegisteredNode>;
+type RegisteredNode = {
+  klass: Klass<LexicalNode>;
+  transforms: Set<Transform<LexicalNode>>;
+  replace: null | ((node: LexicalNode) => LexicalNode);
+  replaceWithKlass: null | Klass<LexicalNode>;
+  exportDOM?: (editor: LexicalEditor, targetNode: LexicalNode) => DOMExportOutput;
+  sharedNodeState: SharedNodeState;
+};
+type Transform<T extends LexicalNode> = (node: T) => void;
+type ErrorHandler = (error: Error) => void;
+type MutationListeners = Map<MutationListener, Set<Klass<LexicalNode>>>;
+type MutatedNodes = Map<Klass<LexicalNode>, Map<NodeKey, NodeMutation>>;
+type NodeMutation = 'created' | 'updated' | 'destroyed';
+interface MutationListenerOptions {
+  /**
+   * Skip the initial call of the listener with pre-existing DOM nodes.
+   *
+   * The default was previously true for backwards compatibility with <= 0.16.1
+   * but this default has been changed to false as of 0.21.0.
+   */
+  skipInitialization?: boolean;
+}
+/**
+ * The payload passed to an UpdateListener
+ */
+interface UpdateListenerPayload {
+  /**
+   * A Map of NodeKeys of ElementNodes to a boolean that is true
+   * if the node was intentionally mutated ('unintentional' mutations
+   * are triggered when an indirect descendant is marked dirty)
+   */
+  dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>;
+  /**
+   * A Set of NodeKeys of all nodes that were marked dirty that
+   * do not inherit from ElementNode.
+   */
+  dirtyLeaves: Set<NodeKey>;
+  /**
+   * The new EditorState after all updates have been processed,
+   * equivalent to `editor.getEditorState()`
+   */
+  editorState: EditorState;
+  /**
+   * The Map of LexicalNode constructors to a `Map<NodeKey, NodeMutation>`,
+   * this is useful when you have a mutation listener type use cases that
+   * should apply to all or most nodes. Will be null if no DOM was mutated,
+   * such as when only the selection changed. Note that this will be empty
+   * unless at least one MutationListener is explicitly registered
+   * (any MutationListener is sufficient to compute the mutatedNodes Map
+   * for all nodes).
+   *
+   * Added in v0.28.0
+   */
+  mutatedNodes: null | MutatedNodes;
+  /**
+   * For advanced use cases only.
+   *
+   * Tracks the keys of TextNode descendants that have been merged
+   * with their siblings by normalization. Note that these keys may
+   * not exist in either editorState or prevEditorState and generally
+   * this is only used for conflict resolution edge cases in collab.
+   */
+  normalizedNodes: Set<NodeKey>;
+  /**
+   * The previous EditorState that is being discarded
+   */
+  prevEditorState: EditorState;
+  /**
+   * The set of tags added with update options or {@link $addUpdateTag},
+   * node that this includes all tags that were processed in this
+   * reconciliation which may have been added by separate updates.
+   */
+  tags: Set<string>;
+}
+/**
+ * A listener that gets called after the editor is updated
+ */
+type UpdateListener = (payload: UpdateListenerPayload) => void;
+type DecoratorListener<T = never> = (decorator: Record<NodeKey, T>) => void;
+type RootListener = (rootElement: null | HTMLElement, prevRootElement: null | HTMLElement) => void;
+type TextContentListener = (text: string) => void;
+type MutationListener = (nodes: Map<NodeKey, NodeMutation>, payload: {
+  updateTags: Set<string>;
+  dirtyLeaves: Set<string>;
+  prevEditorState: EditorState;
+}) => void;
+type CommandListener<P> = (payload: P, editor: LexicalEditor) => boolean;
+type EditableListener = (editable: boolean) => void;
+type CommandListenerPriority = 0 | 1 | 2 | 3 | 4;
+type LexicalCommand<TPayload$1> = {
+  type?: string;
+};
+/**
+ * Type helper for extracting the payload type from a command.
+ *
+ * @example
+ * ```ts
+ * const MY_COMMAND = createCommand<SomeType>();
+ *
+ * // ...
+ *
+ * editor.registerCommand(MY_COMMAND, payload => {
+ *   // Type of `payload` is inferred here. But lets say we want to extract a function to delegate to
+ *   $handleMyCommand(editor, payload);
+ *   return true;
+ * });
+ *
+ * function $handleMyCommand(editor: LexicalEditor, payload: CommandPayloadType<typeof MY_COMMAND>) {
+ *   // `payload` is of type `SomeType`, extracted from the command.
+ * }
+ * ```
+ */
+type CommandPayloadType<TCommand extends LexicalCommand<unknown>> = TCommand extends LexicalCommand<infer TPayload> ? TPayload : never;
+type Commands = Map<LexicalCommand<unknown>, Array<Set<CommandListener<unknown>>>>;
+interface Listeners {
+  decorator: Set<DecoratorListener<any>>;
+  mutation: MutationListeners;
+  editable: Set<EditableListener>;
+  root: Set<RootListener>;
+  textcontent: Set<TextContentListener>;
+  update: Set<UpdateListener>;
+}
+type IntentionallyMarkedAsDirtyElement = boolean;
+type DOMConversionCache = Map<string, Array<(node: Node) => DOMConversion | null>>;
+type SerializedEditor = {
+  editorState: SerializedEditorState;
+};
+declare class LexicalEditor {
+  ['constructor']: KlassConstructor<typeof LexicalEditor>;
+  /** The version with build identifiers for this editor (since 0.17.1) */
+  static version: string | undefined;
+  /** @internal */
+  _headless: boolean;
+  /** @internal */
+  _parentEditor: null | LexicalEditor;
+  /** @internal */
+  _rootElement: null | HTMLElement;
+  /** @internal */
+  _editorState: EditorState;
+  /** @internal */
+  _pendingEditorState: null | EditorState;
+  /** @internal */
+  _compositionKey: null | NodeKey;
+  /** @internal */
+  _deferred: Array<() => void>;
+  /** @internal */
+  _keyToDOMMap: Map<NodeKey, HTMLElement>;
+  /** @internal */
+  _updates: Array<[() => void, EditorUpdateOptions | undefined]>;
+  /** @internal */
+  _updating: boolean;
+  /** @internal */
+  _listeners: Listeners;
+  /** @internal */
+  _commands: Commands;
+  /** @internal */
+  _nodes: RegisteredNodes;
+  /** @internal */
+  _decorators: Record<NodeKey, unknown>;
+  /** @internal */
+  _pendingDecorators: null | Record<NodeKey, unknown>;
+  /** @internal */
+  _config: EditorConfig;
+  /** @internal */
+  _dirtyType: 0 | 1 | 2;
+  /** @internal */
+  _cloneNotNeeded: Set<NodeKey>;
+  /** @internal */
+  _dirtyLeaves: Set<NodeKey>;
+  /** @internal */
+  _dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>;
+  /** @internal */
+  _normalizedNodes: Set<NodeKey>;
+  /** @internal */
+  _updateTags: Set<UpdateTag>;
+  /** @internal */
+  _observer: null | MutationObserver;
+  /** @internal */
+  _key: string;
+  /** @internal */
+  _onError: ErrorHandler;
+  /** @internal */
+  _htmlConversions: DOMConversionCache;
+  /** @internal */
+  _window: null | Window;
+  /** @internal */
+  _editable: boolean;
+  /** @internal */
+  _blockCursorElement: null | HTMLDivElement;
+  /** @internal */
+  _createEditorArgs?: undefined | CreateEditorArgs;
+  /** @internal */
+  constructor(editorState: EditorState, parentEditor: null | LexicalEditor, nodes: RegisteredNodes, config: EditorConfig, onError: ErrorHandler, htmlConversions: DOMConversionCache, editable: boolean, createEditorArgs?: CreateEditorArgs);
+  /**
+   *
+   * @returns true if the editor is currently in "composition" mode due to receiving input
+   * through an IME, or 3P extension, for example. Returns false otherwise.
+   */
+  isComposing(): boolean;
+  /**
+   * Registers a listener for Editor update event. Will trigger the provided callback
+   * each time the editor goes through an update (via {@link LexicalEditor.update}) until the
+   * teardown function is called.
+   *
+   * @returns a teardown function that can be used to cleanup the listener.
+   */
+  registerUpdateListener(listener: UpdateListener): () => void;
+  /**
+   * Registers a listener for for when the editor changes between editable and non-editable states.
+   * Will trigger the provided callback each time the editor transitions between these states until the
+   * teardown function is called.
+   *
+   * @returns a teardown function that can be used to cleanup the listener.
+   */
+  registerEditableListener(listener: EditableListener): () => void;
+  /**
+   * Registers a listener for when the editor's decorator object changes. The decorator object contains
+   * all DecoratorNode keys -> their decorated value. This is primarily used with external UI frameworks.
+   *
+   * Will trigger the provided callback each time the editor transitions between these states until the
+   * teardown function is called.
+   *
+   * @returns a teardown function that can be used to cleanup the listener.
+   */
+  registerDecoratorListener<T>(listener: DecoratorListener<T>): () => void;
+  /**
+   * Registers a listener for when Lexical commits an update to the DOM and the text content of
+   * the editor changes from the previous state of the editor. If the text content is the
+   * same between updates, no notifications to the listeners will happen.
+   *
+   * Will trigger the provided callback each time the editor transitions between these states until the
+   * teardown function is called.
+   *
+   * @returns a teardown function that can be used to cleanup the listener.
+   */
+  registerTextContentListener(listener: TextContentListener): () => void;
+  /**
+   * Registers a listener for when the editor's root DOM element (the content editable
+   * Lexical attaches to) changes. This is primarily used to attach event listeners to the root
+   *  element. The root listener function is executed directly upon registration and then on
+   * any subsequent update.
+   *
+   * Will trigger the provided callback each time the editor transitions between these states until the
+   * teardown function is called.
+   *
+   * @returns a teardown function that can be used to cleanup the listener.
+   */
+  registerRootListener(listener: RootListener): () => void;
+  /**
+   * Registers a listener that will trigger anytime the provided command
+   * is dispatched with {@link LexicalEditor.dispatch}, subject to priority.
+   * Listeners that run at a higher priority can "intercept" commands and
+   * prevent them from propagating to other handlers by returning true.
+   *
+   * Listeners are always invoked in an {@link LexicalEditor.update} and can
+   * call dollar functions.
+   *
+   * Listeners registered at the same priority level will run
+   * deterministically in the order of registration.
+   *
+   * @param command - the command that will trigger the callback.
+   * @param listener - the function that will execute when the command is dispatched.
+   * @param priority - the relative priority of the listener. 0 | 1 | 2 | 3 | 4
+   *   (or {@link COMMAND_PRIORITY_EDITOR} |
+   *     {@link COMMAND_PRIORITY_LOW} |
+   *     {@link COMMAND_PRIORITY_NORMAL} |
+   *     {@link COMMAND_PRIORITY_HIGH} |
+   *     {@link COMMAND_PRIORITY_CRITICAL})
+   * @returns a teardown function that can be used to cleanup the listener.
+   */
+  registerCommand<P>(command: LexicalCommand<P>, listener: CommandListener<P>, priority: CommandListenerPriority): () => void;
+  /**
+   * Registers a listener that will run when a Lexical node of the provided class is
+   * mutated. The listener will receive a list of nodes along with the type of mutation
+   * that was performed on each: created, destroyed, or updated.
+   *
+   * One common use case for this is to attach DOM event listeners to the underlying DOM nodes as Lexical nodes are created.
+   * {@link LexicalEditor.getElementByKey} can be used for this.
+   *
+   * If any existing nodes are in the DOM, and skipInitialization is not true, the listener
+   * will be called immediately with an updateTag of 'registerMutationListener' where all
+   * nodes have the 'created' NodeMutation. This can be controlled with the skipInitialization option
+   * (whose default was previously true for backwards compatibility with &lt;=0.16.1 but has been changed to false as of 0.21.0).
+   *
+   * @param klass - The class of the node that you want to listen to mutations on.
+   * @param listener - The logic you want to run when the node is mutated.
+   * @param options - see {@link MutationListenerOptions}
+   * @returns a teardown function that can be used to cleanup the listener.
+   */
+  registerMutationListener(klass: Klass<LexicalNode>, listener: MutationListener, options?: MutationListenerOptions): () => void;
+  /** @internal */
+  getRegisteredNode(klass: Klass<LexicalNode>): RegisteredNode;
+  /** @internal */
+  resolveRegisteredNodeAfterReplacements(registeredNode: RegisteredNode): RegisteredNode;
+  /** @internal */
+  private initializeMutationListener;
+  /** @internal */
+  private registerNodeTransformToKlass;
+  /**
+   * Registers a listener that will run when a Lexical node of the provided class is
+   * marked dirty during an update. The listener will continue to run as long as the node
+   * is marked dirty. There are no guarantees around the order of transform execution!
+   *
+   * Watch out for infinite loops. See [Node Transforms](https://lexical.dev/docs/concepts/transforms)
+   * @param klass - The class of the node that you want to run transforms on.
+   * @param listener - The logic you want to run when the node is updated.
+   * @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.
+   * @returns True if the editor has registered all of the provided node types, false otherwise.
+   */
+  hasNodes<T extends Klass<LexicalNode>>(nodes: Array<T>): boolean;
+  /**
+   * Dispatches a command of the specified type with the specified payload.
+   * This triggers all command listeners (set by {@link LexicalEditor.registerCommand})
+   * for this type, passing them the provided payload. The command listeners
+   * will be triggered in an implicit {@link LexicalEditor.update}, unless
+   * this was invoked from inside an update in which case that update context
+   * will be re-used (as if this was a dollar function itself).
+   * @param type - the type of command listeners to trigger.
+   * @param payload - the data to pass as an argument to the command listeners.
+   */
+  dispatchCommand<TCommand extends LexicalCommand<unknown>>(type: TCommand, payload: CommandPayloadType<TCommand>): boolean;
+  /**
+   * Gets a map of all decorators in the editor.
+   * @returns A mapping of call decorator keys to their decorated content
+   */
+  getDecorators<T>(): Record<NodeKey, T>;
+  /**
+   *
+   * @returns the current root element of the editor. If you want to register
+   * an event listener, do it via {@link LexicalEditor.registerRootListener}, since
+   * this reference may not be stable.
+   */
+  getRootElement(): null | HTMLElement;
+  /**
+   * Gets the key of the editor
+   * @returns The editor key
+   */
+  getKey(): string;
+  /**
+   * Imperatively set the root contenteditable element that Lexical listens
+   * for events on.
+   */
+  setRootElement(nextRootElement: null | HTMLElement): void;
+  /**
+   * Gets the underlying HTMLElement associated with the LexicalNode for the given key.
+   * @returns the HTMLElement rendered by the LexicalNode associated with the key.
+   * @param key - the key of the LexicalNode.
+   */
+  getElementByKey(key: NodeKey): HTMLElement | null;
+  /**
+   * Gets the active editor state.
+   * @returns The editor state
+   */
+  getEditorState(): EditorState;
+  /**
+   * Imperatively set the EditorState. Triggers reconciliation like an update.
+   * @param editorState - the state to set the editor
+   * @param options - options for the update.
+   */
+  setEditorState(editorState: EditorState, options?: EditorSetOptions): void;
+  /**
+   * Parses a SerializedEditorState (usually produced by {@link EditorState.toJSON}) and returns
+   * and EditorState object that can be, for example, passed to {@link LexicalEditor.setEditorState}. Typically,
+   * deserialization from JSON stored in a database uses this method.
+   * @param maybeStringifiedEditorState
+   * @param updateFn
+   * @returns
+   */
+  parseEditorState(maybeStringifiedEditorState: string | SerializedEditorState, updateFn?: () => void): EditorState;
+  /**
+   * Executes a read of the editor's state, with the
+   * editor context available (useful for exporting and read-only DOM
+   * operations). Much like update, but prevents any mutation of the
+   * editor's state. Any pending updates will be flushed immediately before
+   * the read.
+   * @param callbackFn - A function that has access to read-only editor state.
+   */
+  read<T>(callbackFn: () => T): T;
+  /**
+   * Executes an update to the editor state. The updateFn callback is the ONLY place
+   * where Lexical editor state can be safely mutated.
+   * @param updateFn - A function that has access to writable editor state.
+   * @param options - A bag of options to control the behavior of the update.
+   */
+  update(updateFn: () => void, options?: EditorUpdateOptions): void;
+  /**
+   * Focuses the editor by marking the existing selection as dirty, or by
+   * creating a new selection at `defaultSelection` if one does not already
+   * exist. If you want to force a specific selection, you should call
+   * `root.selectStart()` or `root.selectEnd()` in an update.
+   *
+   * @param callbackFn - A function to run after the editor is focused.
+   * @param options - A bag of options
+   */
+  focus(callbackFn?: () => void, options?: EditorFocusOptions): void;
+  /**
+   * Removes focus from the editor.
+   */
+  blur(): void;
+  /**
+   * Returns true if the editor is editable, false otherwise.
+   * @returns True if the editor is editable, false otherwise.
+   */
+  isEditable(): boolean;
+  /**
+   * Sets the editable property of the editor. When false, the
+   * editor will not listen for user events on the underling contenteditable.
+   * @param editable - the value to set the editable mode to.
+   */
+  setEditable(editable: boolean): void;
+  /**
+   * Returns a JSON-serializable javascript object NOT a JSON string.
+   * You still must call JSON.stringify (or something else) to turn the
+   * state into a string you can transfer over the wire and store in a database.
+   *
+   * See {@link LexicalNode.exportJSON}
+   *
+   * @returns A JSON-serializable javascript object
+   */
+  toJSON(): SerializedEditor;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lexical@0.35.0/node_modules/lexical/LexicalNode.d.ts
+type NodeMap = Map<NodeKey, LexicalNode>;
+/**
+ * The base type for all serialized nodes
+ */
+type SerializedLexicalNode = {
+  /** The type string used by the Node class */
+  type: string;
+  /** A numeric version for this schema, defaulting to 1, but not generally recommended for use */
+  version: number;
+  /**
+   * Any state persisted with the NodeState API that is not
+   * configured for flat storage
+   */
+  [NODE_STATE_KEY]?: Record<string, unknown>;
+};
+/**
+ * EXPERIMENTAL
+ * The configuration of a node returned by LexicalNode.$config()
+ *
+ * @example
+ * ```ts
+ * class CustomText extends TextNode {
+ *   $config() {
+ *     return this.config('custom-text', {extends: TextNode}};
+ *   }
+ * }
+ * ```
+ */
+interface StaticNodeConfigValue<T extends LexicalNode, Type$1 extends string> {
+  /**
+   * The exact type of T.getType(), e.g. 'text' - the method itself must
+   * have a more generic 'string' type to be compatible wtih subclassing.
+   */
+  readonly type?: Type$1;
+  /**
+   * An alternative to the internal static transform() method
+   * that provides better type inference.
+   */
+  readonly $transform?: (node: T) => void;
+  /**
+   * An alternative to the static importJSON() method
+   * that provides better type inference.
+   */
+  readonly $importJSON?: (serializedNode: SerializedLexicalNode) => T;
+  /**
+   * An alternative to the static importDOM() method
+   */
+  readonly importDOM?: DOMConversionMap;
+  /**
+   * EXPERIMENTAL
+   *
+   * An array of RequiredNodeStateConfig to initialize your node with
+   * its state requirements. This may be used to configure serialization of
+   * that state.
+   *
+   * This function will be called (at most) once per editor initialization,
+   * directly on your node's prototype. It must not depend on any state
+   * initialized in the constructor.
+   *
+   * @example
+   * ```ts
+   * const flatState = createState("flat", {parse: parseNumber});
+   * const nestedState = createState("nested", {parse: parseNumber});
+   * class MyNode extends TextNode {
+   *   $config() {
+   *     return this.config(
+   *       'my-node',
+   *       {
+   *         extends: TextNode,
+   *         stateConfigs: [
+   *           { stateConfig: flatState, flat: true},
+   *           nestedState,
+   *         ]
+   *       },
+   *     );
+   *   }
+   * }
+   * ```
+   */
+  readonly stateConfigs?: readonly RequiredNodeStateConfig[];
+  /**
+   * If specified, this must be the exact superclass of the node. It is not
+   * checked at compile time and it is provided automatically at runtime.
+   *
+   * You would want to specify this when you are extending a node that
+   * has non-trivial configuration in its $config such
+   * as required state. If you do not specify this, the inferred
+   * types for your node class might be missing some of that.
+   */
+  readonly extends?: Klass<LexicalNode>;
+}
+/**
+ * This is the type of LexicalNode.$config() that can be
+ * overridden by subclasses.
+ */
+type BaseStaticNodeConfig = { readonly [K in string]?: StaticNodeConfigValue<LexicalNode, string> };
+/**
+ * Any StaticNodeConfigValue (for generics and collections)
+ */
+type AnyStaticNodeConfigValue = StaticNodeConfigValue<any, any>;
+/**
+ * @internal
+ *
+ * This is the more specific type than BaseStaticNodeConfig that a subclass
+ * should return from $config()
+ */
+type StaticNodeConfigRecord<Type$1 extends string, Config$1 extends AnyStaticNodeConfigValue> = BaseStaticNodeConfig & { readonly [K in Type$1]?: Config$1 };
+/**
+ * Omit the children, type, and version properties from the given SerializedLexicalNode definition.
+ */
+type LexicalUpdateJSON<T extends SerializedLexicalNode> = Omit<T, 'children' | 'type' | 'version'>;
+/** @internal */
+interface LexicalPrivateDOM {
+  __lexicalTextContent?: string | undefined | null;
+  __lexicalLineBreak?: HTMLBRElement | HTMLImageElement | undefined | null;
+  __lexicalDirTextContent?: string | undefined | null;
+  __lexicalDir?: 'ltr' | 'rtl' | null | undefined;
+  __lexicalUnmanaged?: boolean | undefined;
+}
+type DOMConversionProp<T extends HTMLElement> = (node: T) => DOMConversion<T> | null;
+type DOMConversion<T extends HTMLElement = HTMLElement> = {
+  conversion: DOMConversionFn<T>;
+  priority?: 0 | 1 | 2 | 3 | 4;
+};
+type DOMConversionFn<T extends HTMLElement = HTMLElement> = (element: T) => DOMConversionOutput | null;
+type DOMChildConversion = (lexicalNode: LexicalNode, parentLexicalNode: LexicalNode | null | undefined) => LexicalNode | null | undefined;
+type DOMConversionMap<T extends HTMLElement = HTMLElement> = Record<NodeName, DOMConversionProp<T>>;
+type NodeName = string;
+type DOMConversionOutput = {
+  after?: (childLexicalNodes: Array<LexicalNode>) => Array<LexicalNode>;
+  forChild?: DOMChildConversion;
+  node: null | LexicalNode | Array<LexicalNode>;
+};
+type DOMExportOutputMap = Map<Klass<LexicalNode>, (editor: LexicalEditor, target: LexicalNode) => DOMExportOutput>;
+type DOMExportOutput = {
+  after?: (generatedElement: HTMLElement | DocumentFragment | Text | null | undefined) => HTMLElement | DocumentFragment | Text | null | undefined;
+  element: HTMLElement | DocumentFragment | Text | null;
+};
+type NodeKey = string;
+declare class LexicalNode {
+  ['constructor']: KlassConstructor<typeof LexicalNode>;
+  /** @internal */
+  __type: string;
+  /** @internal */
+  __key: string;
+  /** @internal */
+  __parent: null | NodeKey;
+  /** @internal */
+  __prev: null | NodeKey;
+  /** @internal */
+  __next: null | NodeKey;
+  /** @internal */
+  __state?: NodeState<this>;
+  /**
+   * Returns the string type of this node. Every node must
+   * implement this and it MUST BE UNIQUE amongst nodes registered
+   * on the editor.
+   *
+   */
+  static getType(): string;
+  /**
+   * Clones this node, creating a new node with a different key
+   * and adding it to the EditorState (but not attaching it anywhere!). All nodes must
+   * implement this method.
+   *
+   */
+  static clone(_data: unknown): LexicalNode;
+  /**
+   * Override this to implement the new static node configuration protocol,
+   * this method is called directly on the prototype and must not depend
+   * on anything initialized in the constructor. Generally it should be
+   * a trivial implementation.
+   *
+   * @example
+   * ```ts
+   * class MyNode extends TextNode {
+   *   $config() {
+   *     return this.config('my-node', {extends: TextNode});
+   *   }
+   * }
+   * ```
+   */
+  $config(): BaseStaticNodeConfig;
+  /**
+   * This is a convenience method for $config that
+   * aids in type inference. See {@link LexicalNode.$config}
+   * for example usage.
+   */
+  config<Type$1 extends string, Config$1 extends StaticNodeConfigValue<this, Type$1>>(type: Type$1, config: Config$1): StaticNodeConfigRecord<Type$1, Config$1>;
+  /**
+   * Perform any state updates on the clone of prevNode that are not already
+   * handled by the constructor call in the static clone method. If you have
+   * state to update in your clone that is not handled directly by the
+   * constructor, it is advisable to override this method but it is required
+   * to include a call to `super.afterCloneFrom(prevNode)` in your
+   * implementation. This is only intended to be called by
+   * {@link $cloneWithProperties} function or via a super call.
+   *
+   * @example
+   * ```ts
+   * class ClassesTextNode extends TextNode {
+   *   // Not shown: static getType, static importJSON, exportJSON, createDOM, updateDOM
+   *   __classes = new Set<string>();
+   *   static clone(node: ClassesTextNode): ClassesTextNode {
+   *     // The inherited TextNode constructor is used here, so
+   *     // classes is not set by this method.
+   *     return new ClassesTextNode(node.__text, node.__key);
+   *   }
+   *   afterCloneFrom(node: this): void {
+   *     // This calls TextNode.afterCloneFrom and LexicalNode.afterCloneFrom
+   *     // for necessary state updates
+   *     super.afterCloneFrom(node);
+   *     this.__addClasses(node.__classes);
+   *   }
+   *   // This method is a private implementation detail, it is not
+   *   // suitable for the public API because it does not call getWritable
+   *   __addClasses(classNames: Iterable<string>): this {
+   *     for (const className of classNames) {
+   *       this.__classes.add(className);
+   *     }
+   *     return this;
+   *   }
+   *   addClass(...classNames: string[]): this {
+   *     return this.getWritable().__addClasses(classNames);
+   *   }
+   *   removeClass(...classNames: string[]): this {
+   *     const node = this.getWritable();
+   *     for (const className of classNames) {
+   *       this.__classes.delete(className);
+   *     }
+   *     return this;
+   *   }
+   *   getClasses(): Set<string> {
+   *     return this.getLatest().__classes;
+   *   }
+   * }
+   * ```
+   *
+   */
+  afterCloneFrom(prevNode: this): void;
+  static importDOM?: () => DOMConversionMap<any> | null;
+  constructor(key?: NodeKey);
+  /**
+   * Returns the string type of this node.
+   */
+  getType(): string;
+  isInline(): boolean;
+  /**
+   * Returns true if there is a path between this node and the RootNode, false otherwise.
+   * This is a way of determining if the node is "attached" EditorState. Unattached nodes
+   * won't be reconciled and will ultimately be cleaned up by the Lexical GC.
+   */
+  isAttached(): boolean;
+  /**
+   * Returns true if this node is contained within the provided Selection., false otherwise.
+   * Relies on the algorithms implemented in {@link BaseSelection.getNodes} to determine
+   * what's included.
+   *
+   * @param selection - The selection that we want to determine if the node is in.
+   */
+  isSelected(selection?: null | BaseSelection): boolean;
+  /**
+   * Returns this nodes key.
+   */
+  getKey(): NodeKey;
+  /**
+   * Returns the zero-based index of this node within the parent.
+   */
+  getIndexWithinParent(): number;
+  /**
+   * Returns the parent of this node, or null if none is found.
+   */
+  getParent<T extends ElementNode>(): T | null;
+  /**
+   * Returns the parent of this node, or throws if none is found.
+   */
+  getParentOrThrow<T extends ElementNode>(): T;
+  /**
+   * Returns the highest (in the EditorState tree)
+   * non-root ancestor of this node, or null if none is found. See {@link lexical!$isRootOrShadowRoot}
+   * for more information on which Elements comprise "roots".
+   */
+  getTopLevelElement(): ElementNode | DecoratorNode<unknown> | null;
+  /**
+   * Returns the highest (in the EditorState tree)
+   * non-root ancestor of this node, or throws if none is found. See {@link lexical!$isRootOrShadowRoot}
+   * for more information on which Elements comprise "roots".
+   */
+  getTopLevelElementOrThrow(): ElementNode | DecoratorNode<unknown>;
+  /**
+   * Returns a list of the every ancestor of this node,
+   * all the way up to the RootNode.
+   *
+   */
+  getParents(): Array<ElementNode>;
+  /**
+   * Returns a list of the keys of every ancestor of this node,
+   * all the way up to the RootNode.
+   *
+   */
+  getParentKeys(): Array<NodeKey>;
+  /**
+   * Returns the "previous" siblings - that is, the node that comes
+   * before this one in the same parent.
+   *
+   */
+  getPreviousSibling<T extends LexicalNode>(): T | null;
+  /**
+   * Returns the "previous" siblings - that is, the nodes that come between
+   * this one and the first child of it's parent, inclusive.
+   *
+   */
+  getPreviousSiblings<T extends LexicalNode>(): Array<T>;
+  /**
+   * Returns the "next" siblings - that is, the node that comes
+   * after this one in the same parent
+   *
+   */
+  getNextSibling<T extends LexicalNode>(): T | null;
+  /**
+   * Returns all "next" siblings - that is, the nodes that come between this
+   * one and the last child of it's parent, inclusive.
+   *
+   */
+  getNextSiblings<T extends LexicalNode>(): Array<T>;
+  /**
+   * @deprecated use {@link $getCommonAncestor}
+   *
+   * Returns the closest common ancestor of this node and the provided one or null
+   * if one cannot be found.
+   *
+   * @param node - the other node to find the common ancestor of.
+   */
+  getCommonAncestor<T extends ElementNode = ElementNode>(node: LexicalNode): T | null;
+  /**
+   * Returns true if the provided node is the exact same one as this node, from Lexical's perspective.
+   * Always use this instead of referential equality.
+   *
+   * @param object - the node to perform the equality comparison on.
+   */
+  is(object: LexicalNode | null | undefined): boolean;
+  /**
+   * Returns true if this node logically precedes the target node in the
+   * editor state, false otherwise (including if there is no common ancestor).
+   *
+   * Note that this notion of isBefore is based on post-order; a descendant
+   * node is always before its ancestors. See also
+   * {@link $getCommonAncestor} and {@link $comparePointCaretNext} for
+   * more flexible ways to determine the relative positions of nodes.
+   *
+   * @param targetNode - the node we're testing to see if it's after this one.
+   */
+  isBefore(targetNode: LexicalNode): boolean;
+  /**
+   * Returns true if this node is an ancestor of and distinct from the target node, false otherwise.
+   *
+   * @param targetNode - the would-be child node.
+   */
+  isParentOf(targetNode: LexicalNode): boolean;
+  /**
+   * Returns a list of nodes that are between this node and
+   * the target node in the EditorState.
+   *
+   * @param targetNode - the node that marks the other end of the range of nodes to be returned.
+   */
+  getNodesBetween(targetNode: LexicalNode): Array<LexicalNode>;
+  /**
+   * Returns true if this node has been marked dirty during this update cycle.
+   *
+   */
+  isDirty(): boolean;
+  /**
+   * Returns the latest version of the node from the active EditorState.
+   * This is used to avoid getting values from stale node references.
+   *
+   */
+  getLatest(): this;
+  /**
+   * Returns a mutable version of the node using {@link $cloneWithProperties}
+   * if necessary. Will throw an error if called outside of a Lexical Editor
+   * {@link LexicalEditor.update} callback.
+   *
+   */
+  getWritable(): this;
+  /**
+   * Returns the text content of the node. Override this for
+   * custom nodes that should have a representation in plain text
+   * format (for copy + paste, for example)
+   *
+   */
+  getTextContent(): string;
+  /**
+   * Returns the length of the string produced by calling getTextContent on this node.
+   *
+   */
+  getTextContentSize(): number;
+  /**
+   * Called during the reconciliation process to determine which nodes
+   * to insert into the DOM for this Lexical Node.
+   *
+   * This method must return exactly one HTMLElement. Nested elements are not supported.
+   *
+   * Do not attempt to update the Lexical EditorState during this phase of the update lifecycle.
+   *
+   * @param _config - allows access to things like the EditorTheme (to apply classes) during reconciliation.
+   * @param _editor - allows access to the editor for context during reconciliation.
+   *
+   * */
+  createDOM(_config: EditorConfig, _editor: LexicalEditor): HTMLElement;
+  /**
+   * Called when a node changes and should update the DOM
+   * in whatever way is necessary to make it align with any changes that might
+   * have happened during the update.
+   *
+   * Returning "true" here will cause lexical to unmount and recreate the DOM node
+   * (by calling createDOM). You would need to do this if the element tag changes,
+   * for instance.
+   *
+   * */
+  updateDOM(_prevNode: unknown, _dom: HTMLElement, _config: EditorConfig): boolean;
+  /**
+   * Controls how the this node is serialized to HTML. This is important for
+   * copy and paste between Lexical and non-Lexical editors, or Lexical editors with different namespaces,
+   * in which case the primary transfer format is HTML. It's also important if you're serializing
+   * to HTML for any other reason via {@link @lexical/html!$generateHtmlFromNodes}. You could
+   * also use this method to build your own HTML renderer.
+   *
+   * */
+  exportDOM(editor: LexicalEditor): DOMExportOutput;
+  /**
+   * Controls how the this node is serialized to JSON. This is important for
+   * copy and paste between Lexical editors sharing the same namespace. It's also important
+   * if you're serializing to JSON for persistent storage somewhere.
+   * See [Serialization & Deserialization](https://lexical.dev/docs/concepts/serialization#lexical---html).
+   *
+   * */
+  exportJSON(): SerializedLexicalNode;
+  /**
+   * Controls how the this node is deserialized from JSON. This is usually boilerplate,
+   * but provides an abstraction between the node implementation and serialized interface that can
+   * be important if you ever make breaking changes to a node schema (by adding or removing properties).
+   * See [Serialization & Deserialization](https://lexical.dev/docs/concepts/serialization#lexical---html).
+   *
+   * */
+  static importJSON(_serializedNode: SerializedLexicalNode): LexicalNode;
+  /**
+   * Update this LexicalNode instance from serialized JSON. It's recommended
+   * to implement as much logic as possible in this method instead of the
+   * static importJSON method, so that the functionality can be inherited in subclasses.
+   *
+   * The LexicalUpdateJSON utility type should be used to ignore any type, version,
+   * or children properties in the JSON so that the extended JSON from subclasses
+   * are acceptable parameters for the super call.
+   *
+   * If overridden, this method must call super.
+   *
+   * @example
+   * ```ts
+   * class MyTextNode extends TextNode {
+   *   // ...
+   *   static importJSON(serializedNode: SerializedMyTextNode): MyTextNode {
+   *     return $createMyTextNode()
+   *       .updateFromJSON(serializedNode);
+   *   }
+   *   updateFromJSON(
+   *     serializedNode: LexicalUpdateJSON<SerializedMyTextNode>,
+   *   ): this {
+   *     return super.updateFromJSON(serializedNode)
+   *       .setMyProperty(serializedNode.myProperty);
+   *   }
+   * }
+   * ```
+   **/
+  updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedLexicalNode>): this;
+  /**
+   * @experimental
+   *
+   * Registers the returned function as a transform on the node during
+   * Editor initialization. Most such use cases should be addressed via
+   * the {@link LexicalEditor.registerNodeTransform} API.
+   *
+   * Experimental - use at your own risk.
+   */
+  static transform(): ((node: LexicalNode) => void) | null;
+  /**
+   * Removes this LexicalNode from the EditorState. If the node isn't re-inserted
+   * somewhere, the Lexical garbage collector will eventually clean it up.
+   *
+   * @param preserveEmptyParent - If falsy, the node's parent will be removed if
+   * it's empty after the removal operation. This is the default behavior, subject to
+   * other node heuristics such as {@link ElementNode#canBeEmpty}
+   * */
+  remove(preserveEmptyParent?: boolean): void;
+  /**
+   * Replaces this LexicalNode with the provided node, optionally transferring the children
+   * of the replaced node to the replacing node.
+   *
+   * @param replaceWith - The node to replace this one with.
+   * @param includeChildren - Whether or not to transfer the children of this node to the replacing node.
+   * */
+  replace<N extends LexicalNode>(replaceWith: N, includeChildren?: boolean): N;
+  /**
+   * Inserts a node after this LexicalNode (as the next sibling).
+   *
+   * @param nodeToInsert - The node to insert after this one.
+   * @param restoreSelection - Whether or not to attempt to resolve the
+   * selection to the appropriate place after the operation is complete.
+   * */
+  insertAfter(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+  /**
+   * Inserts a node before this LexicalNode (as the previous sibling).
+   *
+   * @param nodeToInsert - The node to insert before this one.
+   * @param restoreSelection - Whether or not to attempt to resolve the
+   * selection to the appropriate place after the operation is complete.
+   * */
+  insertBefore(nodeToInsert: LexicalNode, restoreSelection?: boolean): LexicalNode;
+  /**
+   * Whether or not this node has a required parent. Used during copy + paste operations
+   * to normalize nodes that would otherwise be orphaned. For example, ListItemNodes without
+   * a ListNode parent or TextNodes with a ParagraphNode parent.
+   *
+   * */
+  isParentRequired(): boolean;
+  /**
+   * The creation logic for any required parent. Should be implemented if {@link isParentRequired} returns true.
+   *
+   * */
+  createParentElementNode(): ElementNode;
+  selectStart(): RangeSelection;
+  selectEnd(): RangeSelection;
+  /**
+   * Moves selection to the previous sibling of this node, at the specified offsets.
+   *
+   * @param anchorOffset - The anchor offset for selection.
+   * @param focusOffset -  The focus offset for selection
+   * */
+  selectPrevious(anchorOffset?: number, focusOffset?: number): RangeSelection;
+  /**
+   * Moves selection to the next sibling of this node, at the specified offsets.
+   *
+   * @param anchorOffset - The anchor offset for selection.
+   * @param focusOffset -  The focus offset for selection
+   * */
+  selectNext(anchorOffset?: number, focusOffset?: number): RangeSelection;
+  /**
+   * Marks a node dirty, triggering transforms and
+   * forcing it to be reconciled during the update cycle.
+   *
+   * */
+  markDirty(): void;
+  /**
+   * @internal
+   *
+   * When the reconciler detects that a node was mutated, this method
+   * may be called to restore the node to a known good state.
+   */
+  reconcileObservedMutation(dom: HTMLElement, editor: LexicalEditor): void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lexical@0.35.0/node_modules/lexical/nodes/LexicalDecoratorNode.d.ts
+interface DecoratorNode<T> {
+  getTopLevelElement(): ElementNode | this | null;
+  getTopLevelElementOrThrow(): ElementNode | this;
+}
+/** @noInheritDoc */
+declare class DecoratorNode<T> extends LexicalNode {
+  ['constructor']: KlassConstructor<typeof DecoratorNode<T>>;
+  /**
+   * The returned value is added to the LexicalEditor._decorators
+   */
+  decorate(editor: LexicalEditor, config: EditorConfig): T;
+  isIsolated(): boolean;
+  isInline(): boolean;
+  isKeyboardSelectable(): boolean;
+}
+//#endregion
+export { LexicalNodeReplacement as a, TextNode as c, Klass as i, ElementNode as l, SerializedLexicalNode as n, SerializedEditorState as o, EditorConfig as r, TextFormatType as s, LexicalNode as t };
+//# sourceMappingURL=LexicalDecoratorNode-C9hMKfgk.d.mts.map