@prosekit/extensions 0.0.0-next-20240715071354 → 0.0.0-next-20240724172520

package/dist/_tsup-dts-rollup.d.ts

@@ -1,5 +1,7 @@
-import { AddMarkOptions } from '@prosekit/core';
 import { Attrs } from '@prosekit/pm/model';
+import { Attrs as Attrs_2 } from 'prosemirror-model';
+import { BaseCommandsExtension } from '@prosekit/core';
+import { BaseKeymapExtension } from '@prosekit/core';
 import { BundledLanguage } from 'shiki';
 import { BundledLanguageInfo } from 'shiki';
 import { bundledLanguagesInfo } from 'shiki';
@@ -9,45 +11,52 @@ import { bundledThemesInfo } from 'shiki';
 import { Command } from '@prosekit/pm/state';
 import { DedentListOptions } from 'prosemirror-flat-list';
 import { config as default_alias_1 } from '@prosekit/dev/config-vitest';
+import { DocExtension } from '@prosekit/core';
 import { EditorState } from '@prosekit/pm/state';
 import { Extension } from '@prosekit/core';
 import { ExtensionTyping } from '@prosekit/core';
-import { ExtractMarks } from '@prosekit/core';
-import { ExtractNodes } from '@prosekit/core';
+import { ExtractMarkActions } from '@prosekit/core';
+import { ExtractNodeActions } from '@prosekit/core';
+import { GapCursor } from 'prosemirror-gapcursor';
 import { getSingletonHighlighter } from 'shiki/bundle/full';
 import type { Highlighter } from 'shiki';
+import { HistoryExtension } from '@prosekit/core';
 import { IndentListOptions } from 'prosemirror-flat-list';
 import { InputRule } from '@prosekit/pm/inputrules';
-import { InsertNodeOptions } from '@prosekit/core';
-import { ListAttributes } from 'prosemirror-flat-list';
+import type { IsEqual } from 'type-fest';
+import type { ListAttributes } from 'prosemirror-flat-list';
 import { ListDOMSerializer } from 'prosemirror-flat-list';
-import { MarkBuilder } from '@prosekit/core';
 import { MarkType } from '@prosekit/pm/model';
-import { NodeBuilder } from '@prosekit/core';
+import { Node as Node_2 } from 'prosemirror-model';
+import { NodeAction } from '@prosekit/core';
+import { NodeChild } from '@prosekit/core';
 import { NodeJSON } from '@prosekit/core';
 import { NodeType } from '@prosekit/pm/model';
 import { Options } from 'tsup';
 import { Parser } from 'prosemirror-highlight';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
+import { PluginExtension } from '@prosekit/core';
 import { PluginKey } from '@prosekit/pm/state';
 import { ProseMirrorNode } from '@prosekit/pm/model';
-import { RemoveMarkOptions } from '@prosekit/core';
-import { RemoveNodeOptions } from '@prosekit/core';
-import { SetBlockTypeOptions } from '@prosekit/core';
-import { SetNodeAttrsOptions } from '@prosekit/core';
+import { SimplifyDeeper } from '@prosekit/core';
 import type { SpecialLanguage } from 'shiki';
 import { StepJSON } from '@prosekit/core';
 import { TestEditor } from '@prosekit/core/test';
+import { TextExtension } from '@prosekit/core';
 import { ToggleCollapsedOptions } from 'prosemirror-flat-list';
+import { ToMarkAction } from '@prosekit/core';
 import { Transaction } from '@prosekit/pm/state';
-import { UnsetBlockTypeOptions } from '@prosekit/core';
-import { UnsetMarkOptions } from '@prosekit/core';
+import { Union } from '@prosekit/core';
 import { UnwrapListOptions } from 'prosemirror-flat-list';
 import { WrapInListGetAttrs } from 'prosemirror-flat-list';
-import { WrapOptions } from '@prosekit/core';
 
 export declare function applyMarkRules(rules: MarkRuleOptions[], transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): Transaction | null;
 
+/**
+ * Utility function assert that two types are equal in tests.
+ */
+export declare function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void;
+
 declare class AutocompleteRule {
     readonly regex: RegExp;
     readonly onMatch: MatchHandler;
@@ -67,6 +76,43 @@ declare class AutocompleteRule {
 export { AutocompleteRule }
 export { AutocompleteRule as AutocompleteRule_alias_1 }
 
+/**
+ * @internal
+ */
+export declare type BlockquoteExtension = Union<[BlockquoteSpecExtension]>;
+
+/**
+ * @internal
+ */
+export declare type BlockquoteSpecExtension = Extension<{
+    Nodes: {
+        blockquote: Attrs;
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type BoldCommandsExtension = Extension<{
+    Commands: {
+        toggleBold: [];
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type BoldExtension = Union<[BoldSpecExtension, BoldCommandsExtension]>;
+
+/**
+ * @internal
+ */
+export declare type BoldSpecExtension = Extension<{
+    Marks: {
+        bold: Attrs;
+    };
+}>;
+
 export { BundledLanguage as ShikiBundledLanguage }
 export { BundledLanguage as ShikiBundledLanguage_alias_1 }
 
@@ -85,6 +131,9 @@ export { BundledThemeInfo as ShikiBundledThemeInfo_alias_1 }
 export { bundledThemesInfo as shikiBundledThemesInfo }
 export { bundledThemesInfo as shikiBundledThemesInfo_alias_1 }
 
+/**
+ * @public
+ */
 export declare interface CellAttrs {
     colspan: number;
     rowspan: number;
@@ -127,6 +176,29 @@ export declare interface CodeBlockShikiOptions {
     langAlias?: Record<string, BundledLanguage>;
 }
 
+/**
+ * @internal
+ */
+export declare type CodeCommandsExtension = Extension<{
+    Commands: {
+        toggleCode: [];
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type CodeExtension = Union<[CodeSpecExtension, CodeCommandsExtension]>;
+
+/**
+ * @internal
+ */
+export declare type CodeSpecExtension = Extension<{
+    Marks: {
+        code: Attrs;
+    };
+}>;
+
 /**
  * A JSON representation of a commit.
  */
@@ -194,11 +266,7 @@ export declare function defineAutocomplete(rule: AutocompleteRule): Extension;
 /**
  * @public
  */
-export declare function defineBlockquote(): Extension<    {
-Nodes: "blockquote";
-Marks: never;
-Commands: never;
-}>;
+export declare function defineBlockquote(): BlockquoteExtension;
 
 /**
  * Wraps the text block in a blockquote when `>` is typed at the start of a new
@@ -206,51 +274,41 @@ Commands: never;
  */
 export declare function defineBlockquoteInputRule(): Extension<ExtensionTyping<any, any, any>>;
 
-export declare function defineBlockquoteSpec(): Extension<    {
-Nodes: "blockquote";
-Marks: never;
-Commands: never;
+export declare function defineBlockquoteSpec(): Extension<{
+    Nodes: {
+        blockquote: Attrs;
+    };
 }>;
 
 /**
  * @public
  */
-export declare function defineBold(): Extension<    {
-Nodes: never;
-Marks: "bold";
-Commands: {
-toggleBold: [];
-};
-}>;
+export declare function defineBold(): BoldExtension;
 
-export declare function defineBoldCommands(): Extension<    {
-Commands: {
-toggleBold: [];
-};
-Nodes: never;
-Marks: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineBoldCommands(): BoldCommandsExtension;
 
+/**
+ * @internal
+ */
 export declare function defineBoldInputRule(): Extension<ExtensionTyping<any, any, any>>;
 
+/**
+ * @internal
+ */
 export declare function defineBoldKeymap(): Extension<ExtensionTyping<any, any, any>>;
 
-export declare function defineBoldSpec(): Extension<    {
-Marks: "bold";
-Nodes: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineBoldSpec(): BoldSpecExtension;
 
 /**
  * @public
  */
-export declare function defineCode(): Extension<    {
-Nodes: never;
-Marks: "code";
-Commands: {
-toggleCode: [];
-};
-}>;
+export declare function defineCode(): CodeExtension;
 
 /**
  * Adds `codeBlock` nodes to the editor. This includes the following extensions:
@@ -263,16 +321,20 @@ toggleCode: [];
  *
  * @public
  */
-declare function defineCodeBlock(): Extension<    {
-Nodes: "codeBlock";
-Marks: never;
+declare function defineCodeBlock(): Union<readonly [Extension<    {
+Nodes: {
+codeBlock: {
+language: string;
+};
+};
+}>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<ExtensionTyping<any, any, any>>, Extension<    {
 Commands: {
 setCodeBlock: [attrs?: CodeBlockAttrs | undefined];
 insertCodeBlock: [attrs?: CodeBlockAttrs | undefined];
 toggleCodeBlock: [attrs?: CodeBlockAttrs | undefined];
 setCodeBlockAttrs: [attrs: CodeBlockAttrs];
 };
-}>;
+}>]>;
 export { defineCodeBlock }
 export { defineCodeBlock as defineCodeBlock_alias_1 }
 
@@ -288,8 +350,6 @@ insertCodeBlock: [attrs?: CodeBlockAttrs | undefined];
 toggleCodeBlock: [attrs?: CodeBlockAttrs | undefined];
 setCodeBlockAttrs: [attrs: CodeBlockAttrs];
 };
-Nodes: never;
-Marks: never;
 }>;
 export { defineCodeBlockCommands }
 export { defineCodeBlockCommands as defineCodeBlockCommands_alias_1 }
@@ -346,47 +406,44 @@ export { defineCodeBlockShiki as defineCodeBlockShiki_alias_1 }
  * @public
  */
 declare function defineCodeBlockSpec(): Extension<    {
-Nodes: "codeBlock";
-Marks: never;
-Commands: never;
+Nodes: {
+codeBlock: {
+language: string;
+};
+};
 }>;
 export { defineCodeBlockSpec }
 export { defineCodeBlockSpec as defineCodeBlockSpec_alias_1 }
 
-export declare function defineCodeCommands(): Extension<    {
-Commands: {
-toggleCode: [];
-};
-Nodes: never;
-Marks: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineCodeCommands(): CodeCommandsExtension;
 
+/**
+ * @internal
+ */
 export declare function defineCodeInputRule(): Extension<ExtensionTyping<any, any, any>>;
 
+/**
+ * @internal
+ */
 export declare function defineCodeKeymap(): Extension<ExtensionTyping<any, any, any>>;
 
 /**
- * @public
+ * @internal
  */
-export declare function defineCodeSpec(): Extension<    {
-Marks: "code";
-Nodes: never;
-Commands: never;
-}>;
+export declare function defineCodeSpec(): CodeSpecExtension;
 
 /**
  * Define an extension that can record the changes in the editor.
  */
-export declare function defineCommitRecorder(commitRecorder: CommitRecorder): Extension<ExtensionTyping<any, any, any>>;
+export declare function defineCommitRecorder(commitRecorder: CommitRecorder): PluginExtension;
 
 /**
  * Define an extension to display the changes from the given commit in the editor.
  */
-export declare function defineCommitViewer(commit: Commit): Extension<    {
-Nodes: never;
-Marks: never;
-Commands: never;
-}>;
+export declare function defineCommitViewer(commit: Commit): Union<readonly [Extension<ExtensionTyping<any, any, any>>, PluginExtension]>;
 
 /**
  * Show up a decoration at the drop position when something is dragged over the editor.
@@ -395,7 +452,7 @@ Commands: never;
  *
  * @public
  */
-export declare function defineDropCursor(options?: DropCursorOptions): Extension<ExtensionTyping<any, any, any>>;
+export declare function defineDropCursor(options?: DropCursorOptions): DropCursorExtension;
 
 /**
  * Defines an enter rule. An enter rule applies when the text directly in front of
@@ -407,74 +464,71 @@ export declare function defineDropCursor(options?: DropCursorOptions): Extension
 export declare function defineEnterRule({ regex, handler, stop, }: EnterRuleOptions): Extension;
 
 /**
+ * Capture clicks near and arrow-key-motion past places that don't have a
+ * normally selectable position nearby, and create a gap cursor selection for
+ * them. The cursor is drawn as an element with class `ProseMirror-gapcursor`.
+ *
+ * You can either include `prosekit/extensions/gap-cursor.css` or add your own
+ * styles to make it visible.
+ *
+ * See
+ * [prosemirror-gapcursor](https://github.com/ProseMirror/prosemirror-gapcursor)
+ * for more information.
+ *
  * @public
  */
-export declare function defineHeading(): Extension<    {
-Nodes: "heading";
-Marks: never;
-Commands: {
-setHeading: [attrs?: HeadingAttrs | undefined];
-insertHeading: [attrs?: HeadingAttrs | undefined];
-toggleHeading: [attrs?: HeadingAttrs | undefined];
-};
-}>;
+export declare function defineGapCursor(): PluginExtension;
 
-declare function defineHeadingCommands(): Extension<    {
-Commands: {
-setHeading: [attrs?: HeadingAttrs | undefined];
-insertHeading: [attrs?: HeadingAttrs | undefined];
-toggleHeading: [attrs?: HeadingAttrs | undefined];
-};
-Nodes: never;
-Marks: never;
-}>;
+/**
+ * @public
+ */
+export declare function defineHeading(): HeadingExtension;
+
+/**
+ * @internal
+ */
+declare function defineHeadingCommands(): HeadingCommandsExtension;
 export { defineHeadingCommands }
 export { defineHeadingCommands as defineHeadingCommands_alias_1 }
 
 /**
  * Converts the text block to a heading when `#` is typed at the start of a new
  * line followed by a space.
+ *
+ * @internal
  */
 declare function defineHeadingInputRule(): Extension<ExtensionTyping<any, any, any>>;
 export { defineHeadingInputRule }
 export { defineHeadingInputRule as defineHeadingInputRule_alias_1 }
 
+/**
+ * @internal
+ */
 declare function defineHeadingKeymap(): Extension<ExtensionTyping<any, any, any>>;
 export { defineHeadingKeymap }
 export { defineHeadingKeymap as defineHeadingKeymap_alias_1 }
 
-declare function defineHeadingSpec(): Extension<    {
-Nodes: "heading";
-Marks: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+declare function defineHeadingSpec(): HeadingSpecExtension;
 export { defineHeadingSpec }
 export { defineHeadingSpec as defineHeadingSpec_alias_1 }
 
 /**
  * @public
  */
-export declare function defineImage(): Extension<    {
-Nodes: "image";
-Marks: never;
-Commands: {
-insertImage: [attrs?: ImageAttrs | undefined];
-};
-}>;
+export declare function defineImage(): ImageExtension;
 
-export declare function defineImageCommands(): Extension<    {
-Commands: {
-insertImage: [attrs?: ImageAttrs | undefined];
-};
-Nodes: never;
-Marks: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineImageCommands(): ImageCommandsExtension;
 
-export declare function defineImageSpec(): Extension<    {
-Nodes: "image";
-Marks: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineImageSpec(): ImageSpecExtension;
 
 /**
  * Defines an input rule extension.
@@ -488,136 +542,104 @@ export declare function defineInputRule(rule: InputRule): Extension;
 /**
  * @public
  */
-export declare function defineItalic(): Extension<    {
-Nodes: never;
-Marks: "italic";
-Commands: {
-toggleItalic: [];
-};
-}>;
+export declare function defineItalic(): ItalicExtension;
 
-export declare function defineItalicCommands(): Extension<    {
-Commands: {
-toggleItalic: [];
-};
-Nodes: never;
-Marks: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineItalicCommands(): ItalicCommandsExtension;
 
+/**
+ * @internal
+ */
 export declare function defineItalicInputRule(): Extension<ExtensionTyping<any, any, any>>;
 
+/**
+ * @internal
+ */
 export declare function defineItalicKeymap(): Extension<ExtensionTyping<any, any, any>>;
 
-export declare function defineItalicSpec(): Extension<    {
-Marks: "italic";
-Nodes: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineItalicSpec(): ItalicSpecExtension;
 
 /**
  * @public
  */
-export declare function defineLink(): Extension<    {
-Nodes: never;
-Marks: "link";
-Commands: {
-addLink: [attrs: LinkAttrs];
-removeLink: [];
-toggleLink: [attrs: LinkAttrs];
-expandLink: [];
-};
-}>;
+export declare function defineLink(): LinkExtension;
 
-export declare function defineLinkCommands(): Extension<    {
-Commands: {
-addLink: [attrs: LinkAttrs];
-removeLink: [];
-toggleLink: [attrs: LinkAttrs];
-expandLink: [];
-};
-Nodes: never;
-Marks: never;
-}>;
+export declare function defineLinkCommands(): LinkCommandsExtension;
 
 /**
  * Apply link marks after typing Enter.
+ *
+ * @internal
  */
 export declare function defineLinkEnterRule(): Extension<ExtensionTyping<any, any, any>>;
 
 /**
  * Apply link marks after pressing Space.
+ *
+ * @internal
  */
 export declare function defineLinkInputRule(): Extension<ExtensionTyping<any, any, any>>;
 
 /**
  * Apply and remove link marks to the text during typing.
+ *
+ * @internal
  */
 export declare function defineLinkMarkRule(): Extension<ExtensionTyping<any, any, any>>;
 
-export declare function defineLinkSpec(): Extension<    {
-Marks: "link";
-Nodes: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineLinkSpec(): LinkSpecExtension;
 
 /**
  * @public
  */
-export declare function defineList(): Extension<{
-    Nodes: "list";
-    Marks: never;
-    Commands: {
-        dedentList: [options?: DedentListOptions | undefined];
-        indentList: [options?: IndentListOptions | undefined];
-        moveList: [direction: "up" | "down"];
-        splitList: [];
-        toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
-        toggleList: [attrs: ListAttributes];
-        unwrapList: [options?: UnwrapListOptions | undefined];
-        wrapInList: [getAttrs: WrapInListGetAttrs<ListAttributes>];
-        insertList: [attrs?: ListAttributes | undefined];
-    };
-}>;
+export declare function defineList(): ListExtension;
 
 /**
- * Defines list commands
+ * Defines list commands.
+ *
+ * @internal
  */
-declare function defineListCommands(): Extension<    {
-Commands: {
-dedentList: [options?: DedentListOptions | undefined];
-indentList: [options?: IndentListOptions | undefined];
-moveList: [direction: "up" | "down"];
-splitList: [];
-toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
-toggleList: [attrs: ListAttributes];
-unwrapList: [options?: UnwrapListOptions | undefined];
-wrapInList: [getAttrs: WrapInListGetAttrs<ListAttributes>];
-insertList: [attrs?: ListAttributes | undefined];
-};
-Nodes: never;
-Marks: never;
-}>;
+declare function defineListCommands(): ListCommandsExtension;
 export { defineListCommands }
 export { defineListCommands as defineListCommands_alias_1 }
 
-export declare function defineListInputRules(): Extension;
+/**
+ * @internal
+ */
+declare function defineListInputRules(): Extension;
+export { defineListInputRules }
+export { defineListInputRules as defineListInputRules_alias_1 }
 
 /**
  * Returns a extension that adds key bindings for list.
  *
- * @public
+ * @internal
  */
 declare function defineListKeymap(): Extension<ExtensionTyping<any, any, any>>;
 export { defineListKeymap }
 export { defineListKeymap as defineListKeymap_alias_1 }
 
-export declare function defineListPlugins(): Extension<ExtensionTyping<any, any, any>>;
+/**
+ * @internal
+ */
+declare function defineListPlugins(): PluginExtension;
+export { defineListPlugins }
+export { defineListPlugins as defineListPlugins_alias_1 }
 
-export declare function defineListSpec(): Extension<{
-    Nodes: "list";
-    Marks: never;
-    Commands: never;
-}>;
+/**
+ * @internal
+ */
+declare function defineListSpec(): ListSpecExtension;
+export { defineListSpec }
+export { defineListSpec as defineListSpec_alias_1 }
 
 /**
  * Defines an input rule for automatically adding inline marks when a given
@@ -638,29 +660,29 @@ export { defineMarkRule as defineMarkRule_alias_1 }
 /**
  * @public
  */
-export declare function defineMention(): Extension<    {
-Nodes: "mention";
-Marks: never;
+export declare function defineMention(): Union<readonly [Extension<    {
+Nodes: {
+mention: MentionAttrs;
+};
+}>, Extension<    {
 Commands: {
 insertMention: [attrs: MentionAttrs];
 };
-}>;
+}>]>;
 
 export declare function defineMentionCommands(): Extension<    {
 Commands: {
 insertMention: [attrs: MentionAttrs];
 };
-Nodes: never;
-Marks: never;
 }>;
 
 /**
  * @public
  */
 export declare function defineMentionSpec(): Extension<    {
-Nodes: "mention";
-Marks: never;
-Commands: never;
+Nodes: {
+mention: MentionAttrs;
+};
 }>;
 
 /**
@@ -669,18 +691,18 @@ Commands: never;
  *
  * @public
  */
-export declare function defineModClickPrevention(): Extension;
+export declare function defineModClickPrevention(): ModClickPreventionExtension;
 
 /**
  * Add a placeholder text to the editor when the current block or document is
  * empty.
  */
-export declare function definePlaceholder(options: PlaceholderOptions): Extension<ExtensionTyping<any, any, any>>;
+export declare function definePlaceholder(options: PlaceholderOptions): PluginExtension;
 
 /**
  * Make the editor read-only.
  */
-export declare function defineReadonly(): Extension<ExtensionTyping<any, any, any>>;
+export declare function defineReadonly(): PluginExtension;
 
 /**
  * Defines commands for search and replace.
@@ -698,8 +720,6 @@ replaceNextNoWrap: [];
 replaceCurrent: [];
 replaceAll: [];
 };
-Nodes: never;
-Marks: never;
 }>;
 
 /**
@@ -707,58 +727,46 @@ Marks: never;
  *
  * @public
  */
-export declare function defineSearchQuery(options: SearchQueryOptions): Extension<ExtensionTyping<any, any, any>>;
+export declare function defineSearchQuery(options: SearchQueryOptions): PluginExtension;
 
 /**
  * @public
  */
-export declare function defineStrike(): Extension<    {
-Nodes: never;
-Marks: "strike";
-Commands: {
-toggleStrike: [];
-};
-}>;
+export declare function defineStrike(): StrikeExtension;
 
-export declare function defineStrikeCommands(): Extension<    {
-Commands: {
-toggleStrike: [];
-};
-Nodes: never;
-Marks: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineStrikeCommands(): StrikeCommandsExtension;
 
+/**
+ * @internal
+ */
 export declare function defineStrikeInputRule(): Extension<ExtensionTyping<any, any, any>>;
 
+/**
+ * @internal
+ */
 export declare function defineStrikeKeymap(): Extension<ExtensionTyping<any, any, any>>;
 
-export declare function defineStrikeSpec(): Extension<    {
-Marks: "strike";
-Nodes: never;
-Commands: never;
+/**
+ * @internal
+ */
+export declare function defineStrikeSpec(): Extension<{
+    Marks: {
+        strike: Attrs;
+    };
 }>;
 
 /**
  * @public
  */
-export declare function defineTable(): Extension<    {
-Nodes: "table" | "tableRow" | "tableCell" | "tableHeaderCell";
-Marks: never;
-Commands: {
-insertTable: [{
-row: number;
-col: number;
-header: boolean;
-}];
-exitTable: [];
-};
-}>;
+export declare function defineTable(): TableExtension;
 
-declare function defineTableCellSpec(): Extension<    {
-Nodes: "tableCell";
-Marks: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+declare function defineTableCellSpec(): TableCellSpecExtension;
 export { defineTableCellSpec }
 export { defineTableCellSpec as defineTableCellSpec_alias_1 }
 
@@ -767,106 +775,43 @@ export { defineTableCellSpec as defineTableCellSpec_alias_1 }
  *
  * @public
  */
-declare function defineTableCommands(): Extension<    {
-Commands: {
-insertTable: [{
-row: number;
-col: number;
-header: boolean;
-}];
-exitTable: [];
-};
-Nodes: never;
-Marks: never;
-}>;
+declare function defineTableCommands(): TableCommandsExtension;
 export { defineTableCommands }
 export { defineTableCommands as defineTableCommands_alias_1 }
 
-declare function defineTableHeaderCellSpec(): Extension<    {
-Nodes: "tableHeaderCell";
-Marks: never;
-Commands: never;
-}>;
+declare function defineTableHeaderCellSpec(): TableHeaderCellSpecExtension;
 export { defineTableHeaderCellSpec }
 export { defineTableHeaderCellSpec as defineTableHeaderCellSpec_alias_1 }
 
 /**
  * @public
  */
-declare function defineTablePlugins(): Extension<ExtensionTyping<any, any, any>>;
+declare function defineTablePlugins(): PluginExtension;
 export { defineTablePlugins }
 export { defineTablePlugins as defineTablePlugins_alias_1 }
 
-declare function defineTableRowSpec(): Extension<    {
-Nodes: "tableRow";
-Marks: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+declare function defineTableRowSpec(): TableRowSpecExtension;
 export { defineTableRowSpec }
 export { defineTableRowSpec as defineTableRowSpec_alias_1 }
 
-declare function defineTableSpec(): Extension<    {
-Nodes: "table";
-Marks: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+declare function defineTableSpec(): TableSpecExtension;
 export { defineTableSpec }
 export { defineTableSpec as defineTableSpec_alias_1 }
 
 /**
  * @internal
  */
-export declare function defineTestExtension(): Extension<{
-    Nodes: "blockquote" | "table" | "text" | "doc" | "paragraph" | "heading" | "image" | "list" | "tableRow" | "tableCell" | "tableHeaderCell";
-    Marks: "code" | "link" | "bold" | "strike" | "italic" | "underline";
-    Commands: {
-        insertText: [{
-            text: string;
-            from?: number;
-            to?: number;
-        }];
-        insertNode: [options: InsertNodeOptions];
-        removeNode: [options: RemoveNodeOptions];
-        wrap: [WrapOptions];
-        setBlockType: [options: SetBlockTypeOptions];
-        setNodeAttrs: [options: SetNodeAttrsOptions];
-        selectAll: [];
-        addMark: [options: AddMarkOptions];
-        removeMark: [options: RemoveMarkOptions];
-        unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
-        unsetMark: [options?: UnsetMarkOptions | undefined];
-        readonly undo: [];
-        readonly redo: [];
-        toggleBold: [];
-        toggleCode: [];
-        setHeading: [attrs?: HeadingAttrs | undefined];
-        insertHeading: [attrs?: HeadingAttrs | undefined];
-        toggleHeading: [attrs?: HeadingAttrs | undefined];
-        insertImage: [attrs?: ImageAttrs | undefined];
-        toggleItalic: [];
-        addLink: [attrs: LinkAttrs];
-        removeLink: [];
-        toggleLink: [attrs: LinkAttrs];
-        expandLink: [];
-        dedentList: [options?: DedentListOptions | undefined];
-        indentList: [options?: IndentListOptions | undefined];
-        moveList: [direction: "up" | "down"];
-        splitList: [];
-        toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
-        toggleList: [attrs: ListAttributes];
-        unwrapList: [options?: UnwrapListOptions | undefined];
-        wrapInList: [getAttrs: WrapInListGetAttrs<ListAttributes>];
-        insertList: [attrs?: ListAttributes | undefined];
-        toggleStrike: [];
-        insertTable: [{
-            row: number;
-            col: number;
-            header: boolean;
-        }];
-        exitTable: [];
-        toggleUnderline: [];
-    };
-}>;
+export declare function defineTestExtension(): Union<readonly [DocExtension, TextExtension, HeadingExtension, HistoryExtension, ListExtension, BlockquoteExtension, BaseKeymapExtension, BaseCommandsExtension, ItalicExtension, BoldExtension, UnderlineExtension, StrikeExtension, CodeExtension, LinkExtension, ImageExtension, Extension<{
+Nodes: {
+paragraph: Attrs_2;
+};
+}>, TableExtension]>;
 
 /**
  * Adds a `textAlign` attribute to the specified nodes. This will be rendered as
@@ -874,23 +819,20 @@ export declare function defineTestExtension(): Extension<{
  *
  * @public
  */
-export declare function defineTextAlign(options: TextAlignOptions): Extension<{
-    Nodes: never;
-    Marks: never;
-    Commands: {
-        setTextAlign: [value: string | null];
+export declare function defineTextAlign<NodeName extends string = string>(options: TextAlignOptions<NodeName>): Extension<{
+    Nodes: {
+        [K in NodeName]: {
+            textAlign: string | null;
+        };
     };
+    Commands: TextAlignCommandTyping;
 }>;
 
 /**
  * @internal
  */
 export declare function defineTextAlignCommands(types: string[]): Extension<{
-    Commands: {
-        setTextAlign: [value: string | null];
-    };
-    Nodes: never;
-    Marks: never;
+    Commands: TextAlignCommandTyping;
 }>;
 
 /**
@@ -935,29 +877,22 @@ export declare function defineTextBlockInputRule({ regex, type, attrs, }: {
 /**
  * @public
  */
-export declare function defineUnderline(): Extension<    {
-Nodes: never;
-Marks: "underline";
-Commands: {
-toggleUnderline: [];
-};
-}>;
+export declare function defineUnderline(): UnderlineExtension;
 
-export declare function defineUnderlineCommands(): Extension<    {
-Commands: {
-toggleUnderline: [];
-};
-Nodes: never;
-Marks: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineUnderlineCommands(): UnderlineCommandsExtension;
 
+/**
+ * @internal
+ */
 export declare function defineUnderlineKeymap(): Extension<ExtensionTyping<any, any, any>>;
 
-export declare function defineUnderlineSpec(): Extension<    {
-Marks: "underline";
-Nodes: never;
-Commands: never;
-}>;
+/**
+ * @internal
+ */
+export declare function defineUnderlineSpec(): UnderlineSpecExtension;
 
 /**
  * Shows a virtual selection when the editor is not focused. When the editor is
@@ -969,7 +904,7 @@ Commands: never;
  *
  * @public
  */
-export declare function defineVirtualSelection(): Extension;
+export declare function defineVirtualSelection(): VirtualSelectionExtension;
 
 /**
  * Defines an input rule for automatically wrapping a textblock when a given
@@ -1005,6 +940,11 @@ export declare function defineWrappingInputRule({ regex, type, attrs, join, }: {
     join?: (match: RegExpMatchArray, node: ProseMirrorNode) => boolean;
 }): Extension;
 
+/**
+ * @internal
+ */
+export declare type DropCursorExtension = PluginExtension;
+
 export declare interface DropCursorOptions {
     /**
      * The color of the cursor.  Use `false` to apply no color and rely only on class.
@@ -1076,6 +1016,8 @@ export declare type EnterRuleOptions = {
  */
 export declare const exitTable: Command;
 
+export { GapCursor }
+
 export declare function getCheckRanges(transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): Array<[number, number]>;
 
 export declare function getPluginState(state: EditorState): PredictionPluginState | undefined;
@@ -1090,6 +1032,38 @@ declare interface HeadingAttrs {
 export { HeadingAttrs }
 export { HeadingAttrs as HeadingAttrs_alias_1 }
 
+/**
+ * @internal
+ */
+declare type HeadingCommandsExtension = Extension<{
+    Commands: {
+        setHeading: [attrs?: HeadingAttrs | undefined];
+        insertHeading: [attrs?: HeadingAttrs | undefined];
+        toggleHeading: [attrs?: HeadingAttrs | undefined];
+    };
+}>;
+export { HeadingCommandsExtension }
+export { HeadingCommandsExtension as HeadingCommandsExtension_alias_1 }
+
+/**
+ * @internal
+ */
+export declare type HeadingExtension = Union<[
+HeadingSpecExtension,
+HeadingCommandsExtension
+]>;
+
+/**
+ * @internal
+ */
+declare type HeadingSpecExtension = Extension<{
+    Nodes: {
+        heading: HeadingAttrs;
+    };
+}>;
+export { HeadingSpecExtension }
+export { HeadingSpecExtension as HeadingSpecExtension_alias_1 }
+
 export declare type HighlighterOptions = {
     themes: BundledTheme[];
     langs: (BundledLanguage | SpecialLanguage)[];
@@ -1113,10 +1087,36 @@ declare type HighlightParser = Parser;
 export { HighlightParser }
 export { HighlightParser as HighlightParser_alias_1 }
 
+/**
+ * @public
+ */
 export declare interface ImageAttrs {
     src?: string | null;
 }
 
+/**
+ * @internal
+ */
+export declare type ImageCommandsExtension = Extension<{
+    Commands: {
+        insertImage: [attrs?: ImageAttrs];
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type ImageExtension = Union<[ImageSpecExtension, ImageCommandsExtension]>;
+
+/**
+ * @internal
+ */
+export declare type ImageSpecExtension = Extension<{
+    Nodes: {
+        image: ImageAttrs;
+    };
+}>;
+
 export { IndentListOptions }
 
 /**
@@ -1125,11 +1125,42 @@ export { IndentListOptions }
  *
  * @public
  */
-export declare function insertTable({ row, col, header, }: {
+export declare function insertTable({ row, col, header }: InsertTableOptions): Command;
+
+/**
+ * @public
+ */
+export declare interface InsertTableOptions {
     row: number;
     col: number;
     header: boolean;
-}): Command;
+}
+
+/**
+ * @internal
+ */
+export declare type ItalicCommandsExtension = Extension<{
+    Commands: {
+        toggleItalic: [];
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type ItalicExtension = Union<[
+ItalicSpecExtension,
+ItalicCommandsExtension
+]>;
+
+/**
+ * @internal
+ */
+export declare type ItalicSpecExtension = Extension<{
+    Marks: {
+        italic: Attrs;
+    };
+}>;
 
 export declare const LINK_ENTER_RE: RegExp;
 
@@ -1144,10 +1175,95 @@ export declare interface LinkAttrs {
     href: string;
 }
 
-export { ListAttributes }
+/**
+ * @internal
+ */
+export declare type LinkCommandsExtension = Extension<{
+    Commands: {
+        addLink: [LinkAttrs];
+        removeLink: [];
+        toggleLink: [LinkAttrs];
+        expandLink: [];
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type LinkExtension = Union<[LinkSpecExtension, LinkCommandsExtension]>;
+
+/**
+ * @internal
+ */
+export declare type LinkSpecExtension = Extension<{
+    Marks: {
+        link: LinkAttrs;
+    };
+}>;
+
+/**
+ * The attributes of a list node.
+ *
+ * @public
+ */
+declare interface ListAttrs {
+    /**
+     * The kind of list node.
+     */
+    kind?: 'bullet' | 'ordered' | 'task' | 'toggle';
+    /**
+     * The optional order of the list node.
+     */
+    order?: number | null;
+    /**
+     * Whether the list node is checked if its `kind` is `"task"`.
+     */
+    checked?: boolean;
+    /**
+     * Whether the list node is collapsed if its `kind` is `"toggle"`.
+     */
+    collapsed?: boolean;
+}
+export { ListAttrs }
+export { ListAttrs as ListAttrs_alias_1 }
+
+/**
+ * @internal
+ */
+declare type ListCommandsExtension = Extension<{
+    Commands: {
+        dedentList: [options?: DedentListOptions];
+        indentList: [options?: IndentListOptions];
+        moveList: [direction: 'up' | 'down'];
+        splitList: [];
+        toggleCollapsed: [options?: ToggleCollapsedOptions];
+        unwrapList: [options?: UnwrapListOptions];
+        toggleList: [attrs?: ListAttributes];
+        wrapInList: [attrs?: ListAttributes];
+        insertList: [attrs?: ListAttributes];
+    };
+}>;
+export { ListCommandsExtension }
+export { ListCommandsExtension as ListCommandsExtension_alias_1 }
 
 export { ListDOMSerializer }
 
+/**
+ * @internal
+ */
+export declare type ListExtension = Union<[ListSpecExtension, ListCommandsExtension]>;
+
+/**
+ * @internal
+ */
+declare type ListSpecExtension = Extension<{
+    Nodes: {
+        list: ListAttrs;
+    };
+}>;
+export { ListSpecExtension }
+export { ListSpecExtension as ListSpecExtension_alias_1 }
+
 /**
  * Options for {@link defineMarkInputRule}.
  *
@@ -1209,10 +1325,15 @@ export { MatchHandler as MatchHandler_alias_1 }
 
 export declare interface MentionAttrs {
     id: string;
-    kind: string;
     value: string;
+    kind: string;
 }
 
+/**
+ * @internal
+ */
+export declare type ModClickPreventionExtension = PluginExtension;
+
 export declare interface PlaceholderOptions {
     /**
      * The placeholder text to use.
@@ -1311,59 +1432,88 @@ export declare function setTrMeta(tr: Transaction, meta: PredictionPluginState):
  * @internal
  */
 export declare function setupTest(): {
-    editor: TestEditor<Extension<{
-        Nodes: "blockquote" | "table" | "text" | "doc" | "paragraph" | "heading" | "image" | "list" | "tableRow" | "tableCell" | "tableHeaderCell";
-        Marks: "code" | "link" | "bold" | "strike" | "italic" | "underline";
-        Commands: {
-            insertText: [{
-                text: string;
-                from?: number;
-                to?: number;
-            }];
-            insertNode: [options: InsertNodeOptions];
-            removeNode: [options: RemoveNodeOptions];
-            wrap: [WrapOptions];
-            setBlockType: [options: SetBlockTypeOptions];
-            setNodeAttrs: [options: SetNodeAttrsOptions];
-            selectAll: [];
-            addMark: [options: AddMarkOptions];
-            removeMark: [options: RemoveMarkOptions];
-            unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
-            unsetMark: [options?: UnsetMarkOptions | undefined];
-            readonly undo: [];
-            readonly redo: [];
-            toggleBold: [];
-            toggleCode: [];
-            setHeading: [attrs?: HeadingAttrs | undefined];
-            insertHeading: [attrs?: HeadingAttrs | undefined];
-            toggleHeading: [attrs?: HeadingAttrs | undefined];
-            insertImage: [attrs?: ImageAttrs | undefined];
-            toggleItalic: [];
-            addLink: [attrs: LinkAttrs];
-            removeLink: [];
-            toggleLink: [attrs: LinkAttrs];
-            expandLink: [];
-            dedentList: [options?: DedentListOptions | undefined];
-            indentList: [options?: IndentListOptions | undefined];
-            moveList: [direction: "up" | "down"];
-            splitList: [];
-            toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
-            toggleList: [attrs: ListAttributes];
-            unwrapList: [options?: UnwrapListOptions | undefined];
-            wrapInList: [getAttrs: WrapInListGetAttrs<ListAttributes>];
-            insertList: [attrs?: ListAttributes | undefined];
-            toggleStrike: [];
-            insertTable: [{
-                row: number;
-                col: number;
-                header: boolean;
-            }];
-            exitTable: [];
-            toggleUnderline: [];
-        };
+    editor: TestEditor<Union<readonly [DocExtension, TextExtension, HeadingExtension, HistoryExtension, ListExtension, BlockquoteExtension, BaseKeymapExtension, BaseCommandsExtension, ItalicExtension, BoldExtension, UnderlineExtension, StrikeExtension, CodeExtension, LinkExtension, ImageExtension, Extension<{
+    Nodes: {
+    paragraph: Attrs_2;
+    };
+    }>, TableExtension]>>;
+    m: ToMarkAction<SimplifyDeeper<    {
+    bold: {
+    readonly [x: string]: any;
+    };
+    code: {
+    readonly [x: string]: any;
+    };
+    italic: {
+    readonly [x: string]: any;
+    };
+    link: {
+    href: string;
+    };
+    strike: {
+    readonly [x: string]: any;
+    };
+    underline: {
+    readonly [x: string]: any;
+    };
     }>>;
-    n: Record<"blockquote" | "table" | "text" | "doc" | "paragraph" | "heading" | "image" | "list" | "tableRow" | "tableCell" | "tableHeaderCell", NodeBuilder>;
-    m: Record<"code" | "link" | "bold" | "strike" | "italic" | "underline", MarkBuilder>;
+    n: {
+        p: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        h1: (...children: NodeChild[]) => Node_2;
+        h2: (...children: NodeChild[]) => Node_2;
+        h3: (...children: NodeChild[]) => Node_2;
+        h4: (...children: NodeChild[]) => Node_2;
+        h5: (...children: NodeChild[]) => Node_2;
+        h6: (...children: NodeChild[]) => Node_2;
+        bullet: (...children: NodeChild[]) => Node_2;
+        ordered: (...children: NodeChild[]) => Node_2;
+        checked: (...children: NodeChild[]) => Node_2;
+        unchecked: (...children: NodeChild[]) => Node_2;
+        collapsed: (...children: NodeChild[]) => Node_2;
+        expanded: (...children: NodeChild[]) => Node_2;
+        doc: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        paragraph: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        text: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        blockquote: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        heading: NodeAction<    {
+        level: number;
+        }>;
+        image: NodeAction<    {
+        src?: string | null;
+        }>;
+        list: NodeAction<    {
+        kind?: "bullet" | "ordered" | "task" | "toggle";
+        order?: number | null;
+        checked?: boolean;
+        collapsed?: boolean;
+        }>;
+        table: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        tableRow: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        tableCell: NodeAction<    {
+        colspan: number;
+        rowspan: number;
+        colwidth: number[] | null;
+        }>;
+        tableHeaderCell: NodeAction<    {
+        colspan: number;
+        rowspan: number;
+        colwidth: number[] | null;
+        }>;
+    };
 };
 
 /**
@@ -1371,11 +1521,111 @@ export declare function setupTest(): {
  */
 export declare function setupTestFromExtension<E extends Extension>(extension: E): {
     editor: TestEditor<E>;
-    n: Record<ExtractNodes<E>, NodeBuilder>;
-    m: Record<ExtractMarks<E>, MarkBuilder>;
+    n: ExtractNodeActions<E>;
+    m: ExtractMarkActions<E>;
 };
 
-export declare interface TextAlignOptions {
+/**
+ * @internal
+ */
+export declare type StrikeCommandsExtension = Extension<{
+    Commands: {
+        toggleStrike: [];
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type StrikeExtension = Union<[
+StrikeSpecExtension,
+StrikeCommandsExtension
+]>;
+
+/**
+ * @internal
+ */
+export declare type StrikeSpecExtension = Extension<{
+    Marks: {
+        strike: Attrs;
+    };
+}>;
+
+/**
+ * @internal
+ */
+declare type TableCellSpecExtension = Extension<{
+    Nodes: {
+        tableCell: CellAttrs;
+    };
+}>;
+export { TableCellSpecExtension }
+export { TableCellSpecExtension as TableCellSpecExtension_alias_1 }
+
+/**
+ * @internal
+ */
+declare type TableCommandsExtension = Extension<{
+    Commands: {
+        insertTable: [InsertTableOptions];
+        exitTable: [];
+    };
+}>;
+export { TableCommandsExtension }
+export { TableCommandsExtension as TableCommandsExtension_alias_1 }
+
+/**
+ * @internal
+ */
+export declare type TableExtension = Union<[
+TableSpecExtension,
+TableRowSpecExtension,
+TableCellSpecExtension,
+TableHeaderCellSpecExtension,
+TableCommandsExtension
+]>;
+
+/**
+ * @internal
+ */
+declare type TableHeaderCellSpecExtension = Extension<{
+    Nodes: {
+        tableHeaderCell: CellAttrs;
+    };
+}>;
+export { TableHeaderCellSpecExtension }
+export { TableHeaderCellSpecExtension as TableHeaderCellSpecExtension_alias_1 }
+
+/**
+ * @internal
+ */
+declare type TableRowSpecExtension = Extension<{
+    Nodes: {
+        tableRow: Attrs;
+    };
+}>;
+export { TableRowSpecExtension }
+export { TableRowSpecExtension as TableRowSpecExtension_alias_1 }
+
+/**
+ * @internal
+ */
+declare type TableSpecExtension = Extension<{
+    Nodes: {
+        table: Attrs;
+    };
+}>;
+export { TableSpecExtension }
+export { TableSpecExtension as TableSpecExtension_alias_1 }
+
+/**
+ * @internal
+ */
+export declare type TextAlignCommandTyping = {
+    setTextAlign: [value: string | null];
+};
+
+export declare interface TextAlignOptions<NodeName extends string = string> {
     /**
      * The names of node to add the attribute to.
      *
@@ -1383,7 +1633,7 @@ export declare interface TextAlignOptions {
      *
      * ["paragraph", "heading"]
      */
-    types: string[];
+    types: NodeName[];
     /**
      * The default value for the attribute.
      *
@@ -1421,8 +1671,39 @@ export declare type TextBlockEnterRuleOptions = {
 
 export { ToggleCollapsedOptions }
 
+/**
+ * @internal
+ */
+export declare type UnderlineCommandsExtension = Extension<{
+    Commands: {
+        toggleUnderline: [];
+    };
+}>;
+
+/**
+ * @internal
+ */
+export declare type UnderlineExtension = Union<[
+UnderlineSpecExtension,
+UnderlineCommandsExtension
+]>;
+
+/**
+ * @internal
+ */
+export declare type UnderlineSpecExtension = Extension<{
+    Marks: {
+        underline: Attrs;
+    };
+}>;
+
 export { UnwrapListOptions }
 
+/**
+ * @internal
+ */
+export declare type VirtualSelectionExtension = PluginExtension;
+
 export { WrapInListGetAttrs }
 
 export { }