@mdxeditor/editor 0.1.1 → 0.3.0

package/dist/index.d.ts

@@ -9,7 +9,6 @@
 
 import { AdmonitionKind } from 'lexical';
 import type { ComponentType } from 'react';
-import { ContainerDirective } from 'mdast-util-directive';
 import { DecoratorNode } from 'lexical';
 import type { DOMConversionMap } from 'lexical';
 import type { DOMExportOutput } from 'lexical';
@@ -17,25 +16,13 @@ import { EditorConfig } from 'lexical';
 import { EditorThemeClasses } from 'lexical';
 import { ElementNode } from 'lexical';
 import { FromMarkdownOptions } from 'mdast-util-from-markdown/lib';
-import { HeadingNode } from '@lexical/rich-text';
-import { HorizontalRuleNode } from '@lexical/react/LexicalHorizontalRuleNode';
 import { Klass } from 'lexical';
 import { LexicalEditor } from 'lexical';
 import { LexicalNode } from 'lexical';
-import { LineBreakNode } from 'lexical';
-import { LinkNode } from '@lexical/link';
-import { ListItemNode } from '@lexical/list';
-import { ListNode } from '@lexical/list';
 import * as Mdast from 'mdast';
-import { MdxjsEsm } from 'mdast-util-mdx';
 import { MdxJsxAttribute } from 'mdast-util-mdx-jsx';
-import type { MdxJsxFlowElement } from 'mdast-util-mdx-jsx';
-import type { MdxJsxTextElement } from 'mdast-util-mdx-jsx';
-import { MdxJsxTextElement as MdxJsxTextElement_2 } from 'mdast-util-mdx';
 import { NodeKey } from 'lexical';
-import { ParagraphNode } from 'lexical';
 import { ParseOptions } from 'mdast-util-from-markdown/lib';
-import { QuoteNode } from '@lexical/rich-text';
 import * as RadixToolbar from '@radix-ui/react-toolbar';
 import { RangeSelection } from 'lexical';
 import { default as React_2 } from 'react';
@@ -45,41 +32,103 @@ import { SerializedEditorState } from 'lexical';
 import { SerializedElementNode } from 'lexical';
 import { SerializedLexicalNode } from 'lexical';
 import { Spread } from 'lexical';
-import { TextNode } from 'lexical';
+import { ToMarkdownExtension as ToMarkdownExtension_2 } from 'mdast-util-mdx';
 import { Options as ToMarkdownOptions } from 'mdast-util-to-markdown';
+import { ToMarkdownOptions as ToMarkdownOptions_2 } from 'mdast-util-mdx';
 
+/**
+ * Creates an {@link AdmonitionNode}.
+ * @param kind - The kind of admonition to create. Accepts `'note' | 'tip' | 'danger' | 'info' | 'caution'`
+ */
 export declare function $createAdmonitionNode(kind?: AdmonitionKind): AdmonitionNode;
 
-export declare function $createCodeBlockNode({ code, language, meta }: CodeBlockPayload): CodeBlockNode;
+/**
+ * Creates a {@link CodeBlockNode}.
+ * @param options - The code contents, the language  (i.e. js, jsx, etc.), and the additional meta data of the block.
+ */
+export declare function $createCodeBlockNode(options: CreateCodeBlockNodeOptions): CodeBlockNode;
 
-export declare function $createFrontmatterNode({ yaml }: FrontmatterPayload): FrontmatterNode;
+/**
+ * Creates a {@link FrontmatterNode}.
+ * @param yaml - The YAML string of the frontmatter.
+ */
+export declare function $createFrontmatterNode(yaml: string): FrontmatterNode;
 
-export declare function $createImageNode({ altText, title, src, key }: ImagePayload): ImageNode;
+/**
+ * Creates an {@link ImageNode}.
+ * @param options - The payload to create an image. The keys map to the img tag attributes.
+ */
+export declare function $createImageNode(options: CreateImageNodeOptions): ImageNode;
 
-export declare function $createJsxNode(payload: JsxPayload): JsxNode;
+/**
+ * Creates a {@link JsxNode}.
+ * @param options - The payload necessary for the creation of a {@link JsxNode}.
+ *
+ * @see {@link CreateJsxNodeOptions} for more details.
+ */
+export declare function $createJsxNode(options: CreateJsxNodeOptions): JsxNode;
 
-export declare function $createSandpackNode({ code, language, meta }: SandpackPayload): SandpackNode;
+/**
+ * Creates a {@link SandpackNode}.
+ */
+export declare function $createSandpackNode(options: CreateSandpackNodeOptions): SandpackNode;
 
+/**
+ * Creates a {@link TableNode}
+ * @param mdastNode - The mdast node to create the {@link TableNode} from.
+ */
 export declare function $createTableNode(mdastNode: Mdast.Table): TableNode;
 
+/**
+ * Returns `true` if the given node is an {@link AdmonitionNode}.
+ */
 export declare function $isAdmonitionNode(node: LexicalNode | null | undefined): node is AdmonitionNode;
 
+/**
+ * Returns true if the given node is a {@link CodeBlockNode}.
+ */
 export declare function $isCodeBlockNode(node: LexicalNode | null | undefined): node is CodeBlockNode;
 
+/**
+ * Returns `true` if the given node is a {@link FrontmatterNode}.
+ */
 export declare function $isFrontmatterNode(node: LexicalNode | null | undefined): node is FrontmatterNode;
 
+/**
+ * Retruns true if the node is an {@link ImageNode}.
+ */
 export declare function $isImageNode(node: LexicalNode | null | undefined): node is ImageNode;
 
+/**
+ * Returns true if a node is a {@link JsxNode}.
+ */
 export declare function $isJsxNode(node: LexicalNode | null | undefined): node is JsxNode;
 
+/**
+ * Returns true if the given node is a {@link SandpackNode}.
+ */
 export declare function $isSandpackNode(node: LexicalNode | null | undefined): node is SandpackNode;
 
+/**
+ * Retruns true if the given node is a {@link TableNode}.
+ */
 export declare function $isTableNode(node: LexicalNode | null | undefined): node is TableNode;
 
-export declare type ActiveEditorType = LexicalEditorType | CodeBlockEditorType | SandpackEditorType;
-
 export { AdmonitionKind }
 
+/**
+ * A lexical node that represents the markdown directives (better known as admonitions, thanks to Docusaurus). Use {@link "$createAdmonitionNode"} to construct one.
+ *
+ * @remarks
+ *
+ * An admonition in markdown looks like this:
+ *
+ * ```md
+ * :::tip
+ * Some **content** with _Markdown_ `syntax`. Check [this `api`](#).
+ * :::
+ * ```
+ */
 export declare class AdmonitionNode extends ElementNode {
     __kind: AdmonitionKind;
     static getType(): string;
@@ -95,15 +144,13 @@ export declare class AdmonitionNode extends ElementNode {
     collapseAtStart(): true;
 }
 
-export declare interface CodeBlockEditorProps extends SandpackEditorProps {
+declare interface CodeBlockEditorProps extends SandpackEditorProps {
     language: string;
 }
 
-export declare type CodeBlockEditorType = {
-    type: 'codeblock';
-    nodeKey: string;
-};
-
+/**
+ * A lexical node that represents a fenced code block. Use {@link "$createCodeBlockNode"} to construct one.
+ */
 export declare class CodeBlockNode extends DecoratorNode<JSX.Element> {
     __code: string;
     __meta: string;
@@ -129,93 +176,119 @@ export declare class CodeBlockNode extends DecoratorNode<JSX.Element> {
     decorate(_editor: LexicalEditor, { theme: { nodeDecoratorComponents: { CodeBlockEditor } } }: ExtendedEditorConfig): JSX.Element;
 }
 
-export declare interface CodeBlockPayload {
+declare type CoordinatesSubscription = (coords: [colIndex: number, rowIndex: number]) => void;
+
+/**
+ * The options necessary to construct a {@link CodeBlockNode}.
+ */
+export declare interface CreateCodeBlockNodeOptions {
+    /**
+     * The code contents of the block.
+     */
     code: string;
+    /**
+     * The additional meta data of the block.
+     */
     meta: string;
+    /**
+     * The language of the code block (i.e. `js`, `jsx`, etc.). This is used for syntax highlighting.
+     */
     language: string;
 }
 
-export declare type CoordinatesSubscription = (coords: [colIndex: number, rowIndex: number]) => void;
-
-export declare const defaultExtensions: {
-    mdxToMarkdown: ToMarkdownOptions;
-    frontmatterToMarkdown: ToMarkdownOptions;
-    directiveToMarkdown: ToMarkdownOptions;
-    gfmTableToMarkdown: ToMarkdownOptions;
-};
+/**
+ * The payload to create an {@link ImageNode}.
+ */
+export declare interface CreateImageNodeOptions {
+    altText: string;
+    title?: string;
+    key?: NodeKey;
+    src: string;
+}
 
-export declare const defaultLexicalNodes: Record<string, Klass<LexicalNode>>;
-
-export declare const defaultLexicalVisitors: {
-    LexicalRootVisitor: LexicalExportVisitor<RootNode, Mdast.Content>;
-    LexicalParagraphVisitor: LexicalExportVisitor<ParagraphNode, Mdast.Paragraph>;
-    LexicalFrontmatterVisitor: LexicalExportVisitor<FrontmatterNode, Mdast.YAML>;
-    LexicalTextVisitor: LexicalExportVisitor<TextNode, Mdast.Text>;
-    LexicalLinebreakVisitor: LexicalExportVisitor<LineBreakNode, Mdast.Text>;
-    LexicalLinkVisitor: LexicalExportVisitor<LinkNode, Mdast.Link>;
-    LexicalHeadingVisitor: LexicalExportVisitor<HeadingNode, Mdast.Heading>;
-    LexicalListVisitor: LexicalExportVisitor<ListNode, Mdast.List>;
-    LexicalListItemVisitor: LexicalExportVisitor<ListItemNode, Mdast.ListItem>;
-    LexicalQuoteVisitor: LexicalExportVisitor<QuoteNode, Mdast.Blockquote>;
-    SandpackNodeVisitor: LexicalExportVisitor<SandpackNode, Mdast.Code>;
-    CodeBlockVisitor: LexicalExportVisitor<CodeBlockNode, Mdast.Code>;
-    LexicalThematicBreakVisitor: LexicalExportVisitor<HorizontalRuleNode, Mdast.ThematicBreak>;
-    AdmonitionVisitor: LexicalExportVisitor<AdmonitionNode, ContainerDirective>;
-    LexicalImageVisitor: LexicalExportVisitor<ImageNode, Mdast.Image>;
-    JsxVisitor: LexicalExportVisitor<JsxNode, MdxJsxFlowElement | MdxJsxTextElement>;
-    LexicalTableVisitor: LexicalExportVisitor<TableNode, Mdast.Table>;
-};
+/**
+ * The payload to create a {@link JsxNode}.
+ */
+export declare interface CreateJsxNodeOptions {
+    /**
+     * The name of the JSX element.
+     */
+    name: string;
+    /**
+     * The type of the element - markdown makes a distinction between text and flow elements.
+     */
+    kind: JsxKind;
+    /**
+     * The attributes of the JSX element.
+     */
+    attributes: Array<MdxJsxAttribute>;
+    /**
+     * The tree state of the children.
+     */
+    state?: SerializedEditorState;
+    /**
+     * If passed, this function will be called with the root paragraph node of the editor.
+     */
+    updateFn?: updateFn;
+}
 
-export declare const defaultMdastExtensions: Record<string, MarkdownParseOptions['mdastExtensions'][number]>;
+/**
+ * The options necessary to construct a {@link SandpackNode}.
+ */
+export declare interface CreateSandpackNodeOptions {
+    code: string;
+    meta: string;
+    language: string;
+}
 
-export declare const defaultMdastVisitors: Record<string, MdastImportVisitor<Mdast.Content>>;
+/**
+ * The default set of lexical nodes used in the editor.
+ */
+declare const defaultLexicalNodes: Record<string, Klass<LexicalNode>>;
 
-export declare interface DefaultMdxOptionValues {
+/**
+ * A structure that holds the default values for the options used in the markdown import/export steps.
+ *
+ * Most options are exported as records, so that you can pick a specific value using its name rather than its index which can change.
+ * The actual MDXEditor props accept arrays, so you should use the `Object.values` function to convert the records to arrays.
+ */
+export declare type DefaultMdxOptionValues = {
+    /** The default values for the options used in the import step */
     markdownParse: {
-        defaultVisitors: typeof defaultMdastVisitors;
-        defaultSyntaxExtensions: typeof defaultSyntaxExtensions;
-        defaultMdastExtensions: typeof defaultMdastExtensions;
+        defaultVisitors: Record<string, MdastImportVisitor<Mdast.Content>>;
+        defaultSyntaxExtensions: Record<string, SyntaxExtension>;
+        defaultMdastExtensions: Record<string, MdastExtension>;
     };
+    /** The default values for the options used in the markdown export step */
     lexicalConvert: {
-        defaultVisitors: typeof defaultLexicalVisitors;
-        defaultExtensions: typeof defaultExtensions;
-        defaultMarkdownOptions: typeof defaultToMarkdownOptions;
+        defaultVisitors: Record<string, LexicalExportVisitor<LexicalNode, Mdast.Content>>;
+        defaultExtensions: Record<string, ToMarkdownExtension_2>;
+        defaultMarkdownOptions: ToMarkdownOptions_2;
     };
+    /** The default lexical nodes used by the underlying Lexical framework */
     defaultLexicalNodes: typeof defaultLexicalNodes;
-}
+};
 
+/**
+ * Exports the default values for the options used in the markdown import/export steps.
+ */
 export declare const defaultMdxOptionValues: DefaultMdxOptionValues;
 
-export declare const defaultSyntaxExtensions: Record<string, MarkdownParseOptions['syntaxExtensions'][number]>;
-
-export declare const defaultToMarkdownOptions: ToMarkdownOptions;
-
-export declare interface ExportLexicalTreeOptions {
-    root: RootNode;
-    visitors: LexicalVisitor[];
-    jsxComponentDescriptors: JsxComponentDescriptors;
-}
-
-export declare function exportLexicalTreeToMdast({ root, visitors, jsxComponentDescriptors }: ExportLexicalTreeOptions): Mdast.Root;
-
-export declare function exportMarkdownFromLexical({ root, toMarkdownOptions, toMarkdownExtensions, visitors, jsxComponentDescriptors }: ExportMarkdownFromLexicalOptions): string;
-
-export declare interface ExportMarkdownFromLexicalOptions extends ExportLexicalTreeOptions {
-    toMarkdownExtensions: ToMarkdownOptions['extensions'];
-    toMarkdownOptions: ToMarkdownOptions;
-}
-
 declare type ExtendedEditorConfig = EditorConfig & {
     theme: EditorConfig['theme'] & {
         nodeDecoratorComponents: NodeDecoratorComponents;
     };
 };
 
-export declare interface FrontmatterEditorProps {
+declare interface FrontmatterEditorProps {
     yaml: string;
     onChange: (yaml: string) => void;
 }
 
+/**
+ * Represents {@link https://daily-dev-tips.com/posts/what-exactly-is-frontmatter/ | the frontmatter} of the markdown document.
+ * Use {@link "$createFrontmatterNode"} to construct one.
+ */
 export declare class FrontmatterNode extends DecoratorNode<JSX.Element> {
     __yaml: string;
     static getType(): string;
@@ -230,10 +303,9 @@ export declare class FrontmatterNode extends DecoratorNode<JSX.Element> {
     decorate(editor: LexicalEditor, { theme: { nodeDecoratorComponents: { FrontmatterEditor } } }: ExtendedEditorConfig): JSX.Element;
 }
 
-export declare interface FrontmatterPayload {
-    yaml: string;
-}
-
+/**
+ * A lexical node that represents an image. Use {@link "$createImageNode"} to construct one.
+ */
 export declare class ImageNode extends DecoratorNode<JSX.Element> {
     __src: string;
     __altText: string;
@@ -254,36 +326,39 @@ export declare class ImageNode extends DecoratorNode<JSX.Element> {
     decorate(): JSX.Element;
 }
 
-export declare interface ImagePayload {
-    altText: string;
-    title?: string;
-    key?: NodeKey;
-    src: string;
-}
-
-export declare function importMarkdownToLexical({ root, markdown, visitors, syntaxExtensions, mdastExtensions }: MarkdownParseOptions): void;
-
-export declare function importMdastTreeToLexical({ root, mdastRoot, visitors }: MdastTreeImportOptions): void;
-
-export declare type ImportVisitors = Array<MdastImportVisitor<Mdast.Content>>;
-
 declare const IS_BOLD: 1;
 
 declare const IS_ITALIC: 2;
 
 declare const IS_UNDERLINE: 8;
 
+/**
+ * Defines the structure of a JSX component that can be used within the markdown document.
+ */
 export declare interface JsxComponentDescriptor {
+    /**
+     * The tag name
+     */
     name: string;
+    /**
+     * Wether the component is a flow or text component (inline or block)
+     */
     kind: 'flow' | 'text';
+    /**
+     * The module path from which the component can be imported
+     */
     source: string;
+    /**
+     * Wether the component is the default export of the module
+     */
     defaultExport?: boolean;
+    /**
+     * The properties that can be applied to the component
+     */
     props: Array<JsxPropertyDescriptor>;
 }
 
-export declare type JsxComponentDescriptors = Array<JsxComponentDescriptor>;
-
-export declare interface JsxEditorProps {
+declare interface JsxEditorProps {
     kind: JsxKind;
     attributes: MdxJsxAttribute[];
     componentName: string;
@@ -292,8 +367,11 @@ export declare interface JsxEditorProps {
     editor: LexicalEditor;
 }
 
-export declare type JsxKind = 'text' | 'flow';
+declare type JsxKind = 'text' | 'flow';
 
+/**
+ * A lexical node that represents a JSX element. Use {@link "$createJsxNode"} to construct one.
+ */
 export declare class JsxNode extends DecoratorNode<JSX.Element> {
     __kind: JsxKind;
     __name: string;
@@ -315,110 +393,195 @@ export declare class JsxNode extends DecoratorNode<JSX.Element> {
     decorate(_parentEditor: LexicalEditor, { theme: { nodeDecoratorComponents: { JsxEditor } } }: ExtendedEditorConfig): JSX.Element;
 }
 
-export declare interface JsxNodeConstructorParams extends JsxPayload {
+/**
+ * The parameters of the {@link JsxNode} constructor.
+ */
+export declare interface JsxNodeConstructorParams extends CreateJsxNodeOptions {
     key?: NodeKey;
 }
 
-export declare interface JsxPayload {
-    name: string;
-    kind: JsxKind;
-    attributes: Array<MdxJsxAttribute>;
-    state?: SerializedEditorState;
-    updateFn?: updateFn;
-}
-
+/**
+ * Defines the structure of a JSX component property.
+ */
 export declare interface JsxPropertyDescriptor {
+    /**
+     * The name of the property
+     */
     name: string;
+    /**
+     * The type of the property
+     */
     type: 'string' | 'number';
+    /**
+     * Wether the property is required
+     */
     required?: boolean;
 }
 
-export declare type LexicalEditorType = {
-    type: 'lexical';
-};
+/**
+ * Configures how the lexical tree is converted to a mdast tree and then to markdown.
+ */
+export declare interface LexicalConvertOptions {
+    /**
+     * The visitors to use when processing the lexical tree
+     */
+    visitors?: LexicalVisitor[];
+    /**
+     * the markdown extensions to use
+     */
+    toMarkdownExtensions?: Array<ToMarkdownExtension>;
+    /**
+     * The options to pass to `toMarkdown`
+     */
+    toMarkdownOptions?: ToMarkdownOptions;
+}
 
+/**
+ * Implement this interface in order to process mdast node(s) into a lexical tree.
+ * This is part of the process that converts the editor contents to markdown.
+ */
 export declare interface LexicalExportVisitor<LN extends LexicalNode, UN extends Mdast.Content> {
+    /**
+     * Return true if the given node is of the type that this visitor can process.
+     * You can safely use the node type guard functions (as in $isParagraphNode, $isLinkNode, etc.) here.
+     */
     testLexicalNode?(lexicalNode: LexicalNode): lexicalNode is LN;
+    /**
+     * Process the given node and manipulate the mdast tree accordingly.
+     * @see {@link LexicalNodeVisitParams} and {@link LexicalVisitActions} for more information.
+     */
     visitLexicalNode?(params: LexicalNodeVisitParams<LN>): void;
+    /**
+     * Return true if the current node should be joined with the previous node.
+     * This is necessary due to some inconsistencies between the lexical tree and the mdast tree when it comes to formatting.
+     */
     shouldJoin?(prevNode: Mdast.Content, currentNode: UN): boolean;
+    /**
+     * Join the current node with the previous node, returning the resulting new node
+     * For this to be called by the tree walk, shouldJoin must return true.
+     */
     join?<T extends Mdast.Content>(prevNode: T, currentNode: T): T;
 }
 
+/**
+ * The params passed to the {@link LexicalExportVisitor.visitLexicalNode} method.
+ */
 export declare interface LexicalNodeVisitParams<T extends LexicalNode> {
+    /**
+     * The lexical node that is being visited.
+     */
     lexicalNode: T;
+    /**
+     * The mdast parent node that the result of the lexical node conversion should be appended to.
+     */
     mdastParent: Mdast.Parent;
+    /**
+     * A set of actions that can be used to manipulate the mdast tree.
+     * These are "convenience" utilities that avoid the repetitive boilerplate of creating mdast nodes.
+     */
     actions: LexicalVisitActions<T>;
 }
 
+/**
+ * A set of covenience utilities to manipulate the mdast tree when processing lexical nodes.
+ */
 export declare interface LexicalVisitActions<T extends LexicalNode> {
+    /**
+     * Iterate over the immediate children of a lexical node with the given mdast node as a parent.
+     */
     visitChildren(node: T, mdastParent: Mdast.Parent): void;
+    /**
+     * Create a new mdast node with the given type, and props.
+     * Iterate over the immediate children of the current lexical node with the new mdast node as a parent.
+     * @param hasChildren - true by default. Pass false to skip iterating over the lexical node children.
+     */
     addAndStepInto(type: string, props?: Record<string, unknown>, hasChildren?: boolean): void;
+    /**
+     * Append a new mdast node to a parent node.
+     * @param parentNode - the mdast parent node to append the new node to.
+     * @param node - the mdast node to append.
+     */
     appendToParent<T extends Mdast.Parent>(parentNode: T, node: T['children'][number]): T['children'][number] | Mdast.Root;
+    /**
+     * Used when processing JSX nodes so that later, the correct import statement can be added to the document.
+     * @param componentName - the name of the component that has to be imported.
+     * @see {@link JsxComponentDescriptor}
+     */
     registerReferredComponent(componentName: string): void;
 }
 
-export declare type LexicalVisitor = LexicalExportVisitor<LexicalNode, Mdast.Content>;
+declare type LexicalVisitor = LexicalExportVisitor<LexicalNode, Mdast.Content>;
 
+/**
+ * Options that control how the the markdown input string is parsed into a tree.
+ * @see {@link https://github.com/syntax-tree/mdast-util-from-markdown | fromMarkdown}
+ */
 export declare interface MarkdownParseOptions extends Omit<MdastTreeImportOptions, 'mdastRoot'> {
     markdown: string;
     syntaxExtensions: NonNullable<ParseOptions['extensions']>;
     mdastExtensions: NonNullable<FromMarkdownOptions['mdastExtensions']>;
 }
 
-export declare const MdastAdmonitionVisitor: MdastImportVisitor<ContainerDirective>;
-
-export declare const MdastBlockQuoteVisitor: MdastImportVisitor<Mdast.Blockquote>;
-
-export declare const MdastCodeVisitor: MdastImportVisitor<Mdast.Code>;
-
-export declare const MdastFormattingVisitor: MdastImportVisitor<Mdast.Emphasis | Mdast.Strong | MdxJsxTextElement_2>;
-
-export declare const MdastFrontmatterVisitor: MdastImportVisitor<Mdast.YAML>;
-
-export declare const MdastHeadingVisitor: MdastImportVisitor<Mdast.Heading>;
-
-export declare const MdastImageVisitor: MdastImportVisitor<Mdast.Image>;
+/**
+ * An extension for the `fromMarkdown` utility tree construction.
+ */
+declare type MdastExtension = MarkdownParseOptions['mdastExtensions'][number];
 
+/**
+ * Implement this interface to convert certian mdast nodes into lexical nodes.
+ * @typeParam UN - The type of the mdast node that is being visited.
+ */
 export declare interface MdastImportVisitor<UN extends Mdast.Content> {
+    /**
+     * The test function that determines if this visitor should be used for the given node.
+     * As a convenience, you can also pass a string here, which will be compared to the node's type.
+     */
     testNode: ((mdastNode: Mdast.Content | Mdast.Root) => boolean) | string;
+    /**
+     * The function that is called when the node is visited. See {@link MdastVisitParams} for details.
+     */
     visitNode(params: MdastVisitParams<UN>): void;
 }
 
-export declare const MdastInlineCodeVisitor: MdastImportVisitor<Mdast.InlineCode>;
-
-export declare const MdastLinkVisitor: MdastImportVisitor<Mdast.Link>;
-
-export declare const MdastListItemVisitor: MdastImportVisitor<Mdast.ListItem>;
-
-export declare const MdastListVisitor: MdastImportVisitor<Mdast.List>;
-
-export declare const MdastMdxJsEsmVisitor: MdastImportVisitor<MdxjsEsm>;
-
-export declare const MdastMdxJsxElementVisitor: MdastImportVisitor<MdxJsxTextElement_2>;
-
-export declare const MdastParagraphVisitor: MdastImportVisitor<Mdast.Paragraph>;
-
-export declare const MdastRootVisitor: MdastImportVisitor<Mdast.Content>;
-
-export declare const MdastTableVisitor: MdastImportVisitor<Mdast.Table>;
-
-export declare const MdastTextVisitor: MdastImportVisitor<Mdast.Text>;
-
-export declare const MdastThematicBreakVisitor: MdastImportVisitor<Mdast.ThematicBreak>;
-
+/**
+ * The options of the tree import utility. Not meant to be used directly.
+ */
 export declare interface MdastTreeImportOptions {
     root: RootNode;
     visitors: Array<MdastImportVisitor<Mdast.Content>>;
     mdastRoot: Mdast.Root;
 }
 
+/**
+ * A set of actions that can be used to modify the lexical tree while visiting the mdast tree.
+ */
 export declare interface MdastVisitActions {
+    /**
+     * Iterate the children of the node with the lexical node as the parent.
+     */
     visitChildren(node: Mdast.Parent, lexicalParent: LexicalNode): void;
+    /**
+     * Add the given node to the lexical tree, and iterate the current mdast node's children with the newly created lexical node as a parent.
+     */
     addAndStepInto(lexicalNode: LexicalNode): void;
+    /**
+     * Adds formatting as a context for the current node and its children.
+     * This is necessary due to mdast treating formatting as a node, while lexical considering it an attribute of a node.
+     */
     addFormatting(format: typeof IS_BOLD | typeof IS_ITALIC | typeof IS_UNDERLINE): void;
+    /**
+     * Access the current formatting context.
+     */
     getParentFormatting(): number;
 }
 
+/**
+ * Parameters passe to the {@link MdastImportVisitor.visitNode} function.
+ * @param mdastNode - The node that is currently being visited.
+ * @param lexicalParent - The parent lexical node to which the results of the processing should be added.
+ * @param actions - A set of convenience utilities that can be used to add nodes to the lexical tree.
+ * @typeParam T - The type of the mdast node that is being visited.
+ */
 export declare interface MdastVisitParams<T extends Mdast.Content> {
     mdastNode: T;
     lexicalParent: LexicalNode;
@@ -462,9 +625,9 @@ export declare interface MDXEditorProps {
     headMarkdown?: string;
     /**
      * The configuration for the JSX components used in the markdown content.
-     * @see the {@link JsxComponentDescriptors} interface for more details.
+     * @see the {@link JsxComponentDescriptor} interface for more details.
      */
-    jsxComponentDescriptors?: JsxComponentDescriptors;
+    jsxComponentDescriptors?: JsxComponentDescriptor[];
     /**
      * The list of suggestions to be shown in the link autocomplete dialog dropdown.
      */
@@ -481,12 +644,36 @@ export declare interface MDXEditorProps {
      * The initial view mode for the editor. Defaults to `ViewMode.editor`.
      */
     viewMode?: ViewMode;
+    /**
+     * Triggered when the markdown content changes.
+     */
     onChange?: (markdown: string) => void;
+    /**
+     * The CSS class name to be applied to the wrapper element of the component.
+     */
     className?: string;
+    /**
+     * The CSS class name to be applied to the content editable element.
+     */
     contentEditableClassName?: string;
+    /**
+     * The options to be used when parsing the markdown content.
+     * @see the {@link MarkdownParseOptions} interface for more details.
+     */
     markdownParseOptions?: Partial<MarkdownParseOptions>;
+    /**
+     * The {@link https://lexical.dev/ | Lexical nodes} used by the editor.
+     */
     lexicalNodes?: Klass<LexicalNode>[];
-    lexicalConvertOptions?: Partial<ExportMarkdownFromLexicalOptions>;
+    /**
+     * The options used when converting the lexical tree to markdown.
+     * @see the {@link LexicalConvertOptions} interface for more details.
+     */
+    lexicalConvertOptions?: LexicalConvertOptions;
+    /**
+     * The supported code block languages.
+     */
+    codeBlockLanguages?: Record<string, string>;
 }
 
 declare interface NodeDecoratorComponents {
@@ -498,20 +685,20 @@ declare interface NodeDecoratorComponents {
 }
 
 /**
- * The configuration for the available sandpack presets
+ * The configuration for the available sandpack presets.
  */
 export declare interface SandpackConfig {
     /**
-     * The name of the default preset that will be used if no meta (other than live) is set
+     * The name of the default preset that will be used if no meta (other than live) is set.
      */
     defaultPreset: string;
     /**
-     * The list of sandpack presets that can be used
+     * The list of sandpack presets that can be used.
      */
     presets: Array<SandpackPreset>;
 }
 
-export declare interface SandpackEditorProps {
+declare interface SandpackEditorProps {
     code: string;
     nodeKey: string;
     meta: string;
@@ -519,11 +706,9 @@ export declare interface SandpackEditorProps {
     focusEmitter: VoidEmitter;
 }
 
-export declare type SandpackEditorType = {
-    type: 'sandpack';
-    nodeKey: string;
-};
-
+/**
+ * A lexical node that represents a live code block that gets a preview. Use {@link "$createSandpackNode"} to construct one.
+ */
 export declare class SandpackNode extends DecoratorNode<JSX.Element> {
     __code: string;
     __meta: string;
@@ -549,22 +734,16 @@ export declare class SandpackNode extends DecoratorNode<JSX.Element> {
     decorate(_parentEditor: LexicalEditor, { theme: { nodeDecoratorComponents: { SandpackEditor } } }: ExtendedEditorConfig): JSX.Element;
 }
 
-export declare interface SandpackPayload {
-    code: string;
-    meta: string;
-    language: string;
-}
-
 /**
  * Defines a single preset that can be used to create a sandbox.
  */
 export declare interface SandpackPreset {
     /**
-     * The name of the preset - use this to reference the preset from the defaultPreset field
+     * The name of the preset - use this to reference the preset from the defaultPreset field.
      */
     name: string;
     /**
-     * The label of th preset, displayed in the sandpack button dropdown
+     * The label of the preset, displayed in the sandpack button dropdown.
      */
     label: string;
     /**
@@ -580,11 +759,11 @@ export declare interface SandpackPreset {
      */
     sandpackTheme: SandpackProviderProps['theme'];
     /**
-     * The name of the file that will be created in the sandbox. e.g. "/App.js"
+     * The name of the file that will be created in the sandbox. e.g. "/App.js".
      */
     snippetFileName: string;
     /**
-     * The dependencies that will be added to the sandbox, just like in package.json
+     * The dependencies that will be added to the sandbox, just like in package.json.
      */
     dependencies?: Record<string, string>;
     /**
@@ -593,7 +772,7 @@ export declare interface SandpackPreset {
      */
     files?: Record<string, string>;
     /**
-     * The language used in the editable snippet. e.g. "jsx", "tsx", etc
+     * The language used in the editable snippet. e.g. "jsx", "tsx", etc.
      */
     snippetLanguage?: string;
     /**
@@ -604,22 +783,34 @@ export declare interface SandpackPreset {
 
 declare type SandpackProviderProps = React_2.ComponentProps<typeof SandpackProvider>;
 
+/**
+ * A serialized representation of an {@link AdmonitionNode}.
+ */
 export declare type SerializedAdmonitionNode = Spread<{
     type: 'admonition';
     kind: AdmonitionKind;
     version: 1;
 }, SerializedElementNode>;
 
-export declare type SerializedCodeBlockNode = Spread<CodeBlockPayload & {
+/**
+ * A serialized representation of an {@link CodeBlockNode}.
+ */
+export declare type SerializedCodeBlockNode = Spread<CreateCodeBlockNodeOptions & {
     type: 'codeblock';
     version: 1;
 }, SerializedLexicalNode>;
 
+/**
+ * A serialized representation of an {@link FrontmatterNode}.
+ */
 export declare type SerializedFrontmatterNode = Spread<{
     yaml: string;
     version: 1;
 }, SerializedLexicalNode>;
 
+/**
+ * A serialized representation of an {@link ImageNode}.
+ */
 export declare type SerializedImageNode = Spread<{
     altText: string;
     title?: string;
@@ -628,26 +819,44 @@ export declare type SerializedImageNode = Spread<{
     version: 1;
 }, SerializedLexicalNode>;
 
-export declare type SerializedJsxNode = Spread<Omit<JsxPayload, 'updateFn'> & {
+/**
+ * A serialized representation of a {@link JsxNode}.
+ */
+export declare type SerializedJsxNode = Spread<Omit<CreateJsxNodeOptions, 'updateFn'> & {
     version: 1;
     type: 'jsx';
 }, SerializedLexicalNode>;
 
-export declare type SerializedSandpackNode = Spread<SandpackPayload & {
+/**
+ * A serialized representation of an {@link SandpackNode}.
+ */
+export declare type SerializedSandpackNode = Spread<CreateSandpackNodeOptions & {
     type: 'sandpack';
     version: 1;
 }, SerializedLexicalNode>;
 
+/**
+ * A serialized representation of a {@link TableNode}.
+ */
 export declare type SerializedTableNode = Spread<{
     mdastNode: Mdast.Table;
 }, SerializedLexicalNode>;
 
-export declare interface TableEditorProps {
+/**
+ * An extension for the `fromMarkdown` utility markdown parse.
+ */
+declare type SyntaxExtension = MarkdownParseOptions['syntaxExtensions'][number];
+
+declare interface TableEditorProps {
     parentEditor: LexicalEditor;
     lexicalTable: TableNode;
     mdastNode: Mdast.Table;
 }
 
+/**
+ * A lexical node that represents a table, with features specific to the markdown tables.
+ * Use {@link "$createTableNode"} to construct one.
+ */
 export declare class TableNode extends DecoratorNode<JSX.Element> {
     __mdastNode: Mdast.Table;
     focusEmitter: {
@@ -677,8 +886,14 @@ export declare class TableNode extends DecoratorNode<JSX.Element> {
     isInline(): false;
 }
 
+declare type ToMarkdownExtension = NonNullable<ToMarkdownOptions['extensions']>[number];
+
 export { ToMarkdownOptions }
 
+/**
+ * A dictionary with all built-in Toolbar components that can be used within the toolbar.
+ * @see To customize the toolbar, pass an array of what you need to the {@link MDXEditorProps.toolbarComponents}.
+ */
 export declare const ToolbarComponents: {
     BlockTypeSelect: () => React_2.JSX.Element;
     BoldItalicUnderlineButtons: React_2.FC<{}>;
@@ -712,9 +927,9 @@ export declare type updateFn = (node: LexicalNode) => void;
  * markdown - plain text markdown edit mode.
  * diff - side by side comparison with the original markdown (passed as `headMarkdown`).
  */
-export declare type ViewMode = 'editor' | 'markdown' | 'diff';
+declare type ViewMode = 'editor' | 'markdown' | 'diff';
 
-export declare interface VoidEmitter {
+declare interface VoidEmitter {
     publish: () => void;
     subscribe: (callback: () => void) => void;
 }