@prosekit/core 0.0.0-next-20240724172520 → 0.0.0-next-20240901092634

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

@@ -1,29 +1,30 @@
 import { AllSelection } from '@prosekit/pm/state';
-import { Attrs } from '@prosekit/pm/model';
-import { Attrs as Attrs_2 } from 'prosemirror-model';
+import type { Attrs } from '@prosekit/pm/model';
 import { Command } from '@prosekit/pm/state';
 import type { ContentMatch } from '@prosekit/pm/model';
 import { config as default_alias_1 } from '@prosekit/dev/config-vitest';
 import type { DirectEditorProps } from '@prosekit/pm/view';
 import type { DOMEventMap } from '@prosekit/pm/view';
+import type { DOMOutputSpec } from '@prosekit/pm/model';
 import { DOMParser as DOMParser_2 } from '@prosekit/pm/model';
 import { DOMSerializer } from '@prosekit/pm/model';
 import { EditorState } from '@prosekit/pm/state';
 import type { EditorStateConfig } from '@prosekit/pm/state';
 import { EditorView } from '@prosekit/pm/view';
+import { Fragment } from '@prosekit/pm/model';
 import type { IsEqual } from 'type-fest';
 import { Mark } from '@prosekit/pm/model';
 import type { MarkSpec } from '@prosekit/pm/model';
-import { MarkType } from '@prosekit/pm/model';
+import type { MarkType } from '@prosekit/pm/model';
 import type { Node as Node_2 } from '@prosekit/pm/model';
 import { NodeSelection } from '@prosekit/pm/state';
 import type { NodeSpec } from '@prosekit/pm/model';
-import { NodeType } from '@prosekit/pm/model';
+import type { NodeType } from '@prosekit/pm/model';
 import { NodeType as NodeType_2 } from 'prosemirror-model';
 import type { NodeView } from '@prosekit/pm/view';
 import type { NodeViewConstructor } from '@prosekit/pm/view';
 import { Options } from 'tsup';
-import type { ParseOptions } from '@prosekit/pm/model';
+import { ParseOptions } from '@prosekit/pm/model';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
 import { ProseMirrorFragment } from '@prosekit/pm/model';
 import { ProseMirrorNode } from '@prosekit/pm/model';
@@ -33,7 +34,8 @@ import { SchemaSpec } from '@prosekit/pm/model';
 import { Selection as Selection_2 } from '@prosekit/pm/state';
 import { Selection as Selection_3 } from 'prosemirror-state';
 import type { Simplify } from 'type-fest';
-import type { Slice } from '@prosekit/pm/model';
+import { Slice } from '@prosekit/pm/model';
+import type { TagParseRule } from '@prosekit/pm/model';
 import { TextSelection } from '@prosekit/pm/state';
 import { Transaction } from '@prosekit/pm/state';
 import type { UnionToIntersection } from 'type-fest';
@@ -121,6 +123,12 @@ export declare function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void;
  */
 export declare function assertTypeEqual_alias_1<T, U>(_val: IsEqual<T, U>): void;
 
+declare interface AttrOptions {
+    attr: string;
+    toDOM?: (value: unknown) => [key: string, value: string] | null | undefined;
+    parseDOM?: (node: HTMLElement) => unknown;
+}
+
 export declare function attrsMatch(nodeOrMark: ProseMirrorNode | Mark, attrs: Attrs): boolean;
 
 /**
@@ -159,6 +167,7 @@ declare type BaseCommandsExtension = Extension<{
         wrap: [options: WrapOptions];
         setBlockType: [options: SetBlockTypeOptions];
         setNodeAttrs: [options: SetNodeAttrsOptions];
+        insertDefaultBlock: [options?: InsertDefaultBlockOptions];
         selectAll: [];
         addMark: [options: AddMarkOptions];
         removeMark: [options: RemoveMarkOptions];
@@ -195,11 +204,7 @@ export declare abstract class BaseExtension<T extends ExtensionTyping = Extensio
 /**
  * @internal
  */
-declare type BaseKeymapExtension = Extension<{
-    Nodes: never;
-    Commands: never;
-    Keymap: never;
-}>;
+declare type BaseKeymapExtension = PlainExtension;
 export { BaseKeymapExtension }
 export { BaseKeymapExtension as BaseKeymapExtension_alias_1 }
 
@@ -229,9 +234,11 @@ declare interface BaseNodeViewOptions {
 export { BaseNodeViewOptions }
 export { BaseNodeViewOptions as BaseNodeViewOptions_alias_1 }
 
-export declare function baseToggleMark(markType: MarkType, attrs?: Attrs | null, options?: {
-    removeWhenPresent: boolean;
-}): Command;
+declare type BoldExtension = Extension<{
+    Marks: {
+        bold: Attrs;
+    };
+}>;
 
 export declare function buildNode(type: NodeType, args: [Attrs | NodeChild | null | undefined, ...NodeChild[]], createNode: CreateNodeFunction): ProseMirrorNode;
 
@@ -260,26 +267,59 @@ declare const clsx: (...args: Array<string | boolean | null | undefined>) => str
 export { clsx }
 export { clsx as clsx_alias_1 }
 
+declare type CodeBlockExtension = Extension<{
+    Nodes: {
+        codeBlock: {
+            language: string;
+        };
+    };
+}>;
+
+/**
+ * Collects all children of a node or a fragment, and returns them as an array.
+ *
+ * @public
+ */
+declare function collectChildren(parent: ProseMirrorNode | Fragment): ProseMirrorNode[];
+export { collectChildren }
+export { collectChildren as collectChildren_alias_1 }
+
 /**
  * Collects all nodes from a given content.
  *
+ * @deprecated Use `collectChildren` instead.
+ *
  * @public
  */
 declare function collectNodes(content: NodeContent): ProseMirrorNode[];
 export { collectNodes }
 export { collectNodes as collectNodes_alias_1 }
 
-export declare function combineEventHandlers<Handler extends (...args: any[]) => boolean | void, Args extends Parameters<Handler> = Parameters<Handler>>(): readonly [(handlers: Handler[]) => void, (...args: Args) => boolean];
+export declare function combineEventHandlers<Handler extends (...args: any[]) => boolean | void, Args extends Parameters<Handler> = Parameters<Handler>>(): readonly [(eventHandlers: Handler[]) => void, (...args: Args) => boolean];
 
 /**
  * A function to apply a command to the editor. It will return `true` if the command was applied, and `false` otherwise.
  *
- * It also has a `canApply` method to check if the command can be applied.
+ * It also has a `canExec` method to check if the command can be applied.
  *
  * @public
  */
 declare interface CommandAction<Args extends any[] = any[]> {
+    /**
+     * Execute the current command. Return `true` if the command was successfully
+     * executed, otherwise `false`.
+     */
     (...args: Args): boolean;
+    /**
+     * Check if the current command can be executed. Return `true` if the command
+     * can be executed, otherwise `false`.
+     */
+    canExec(...args: Args): boolean;
+    /**
+     * An alias for `canExec`.
+     *
+     * @deprecated Use `canExec` instead.
+     */
     canApply(...args: Args): boolean;
 }
 export { CommandAction }
@@ -321,12 +361,12 @@ export { createEditor as createEditor_alias_1 }
 /**
  * @internal
  */
-export declare function createMarkActions(schema: Schema, getState: () => EditorState | null | undefined, applyMark?: ApplyMarkFunction): Record<string, MarkAction>;
+export declare function createMarkActions(schema: Schema, getState: GetStateFunction, applyMark?: ApplyMarkFunction): Record<string, MarkAction>;
 
 /**
  * @internal
  */
-export declare function createNodeActions(schema: Schema, getState: () => EditorState | null | undefined, createNode?: CreateNodeFunction): Record<string, NodeAction>;
+export declare function createNodeActions(schema: Schema, getState: GetStateFunction, createNode?: CreateNodeFunction): Record<string, NodeAction>;
 
 export declare const createNodeForTest: CreateNodeFunction;
 
@@ -355,20 +395,32 @@ declare function defaultBlockAt(match: ContentMatch): NodeType_2 | null;
 export { defaultBlockAt }
 export { defaultBlockAt as defaultBlockAt_alias_1 }
 
+/**
+ * @public
+ */
 declare interface DefaultStateOptions {
+    /**
+     * The starting document to use when creating the editor. It can be a
+     * ProseMirror node JSON object, a HTML string, or a HTML element instance.
+     */
+    defaultContent?: NodeJSON | string | HTMLElement;
     /**
      * A JSON object representing the starting document to use when creating the
      * editor.
+     *
+     * @deprecated Use `defaultContent` instead.
      */
     defaultDoc?: NodeJSON;
     /**
      * A HTML element or a HTML string representing the starting document to use
      * when creating the editor.
+     *
+     * @deprecated Use `defaultContent` instead.
      */
     defaultHTML?: string | HTMLElement;
     /**
      * A JSON object representing the starting selection to use when creating the
-     * editor. It's only used when `defaultDoc` or `defaultHTML` is also provided.
+     * editor. It's only used when `defaultContent` is also provided.
      */
     defaultSelection?: SelectionJSON;
 }
@@ -426,7 +478,14 @@ declare function defineCommands<T extends Record<string, CommandCreator> = Recor
 export { defineCommands }
 export { defineCommands as defineCommands_alias_1 }
 
-declare function defineDefaultState({ defaultDoc, defaultHTML, defaultSelection, }: DefaultStateOptions): Extension;
+/**
+ * Define a default state for the editor.
+ *
+ * @param options
+ *
+ * @public
+ */
+declare function defineDefaultState({ defaultSelection, defaultContent, defaultDoc, defaultHTML, }: DefaultStateOptions): PlainExtension;
 export { defineDefaultState }
 export { defineDefaultState as defineDefaultState_alias_1 }
 
@@ -442,7 +501,7 @@ export { defineDoc as defineDoc_alias_1 }
  *
  * @public
  */
-declare function defineDocChangeHandler(handler: DocChangeHandler): Extension<ExtensionTyping<any, any, any>>;
+declare function defineDocChangeHandler(handler: DocChangeHandler): PlainExtension;
 export { defineDocChangeHandler }
 export { defineDocChangeHandler as defineDocChangeHandler_alias_1 }
 
@@ -528,6 +587,8 @@ export { defineFocusChangeHandler as defineFocusChangeHandler_alias_1 }
 /**
  * Add undo/redo history to the editor.
  *
+ * @param options
+ *
  * @public
  */
 declare function defineHistory({ depth, newGroupDelay, }?: HistoryOptions): HistoryExtension;
@@ -546,7 +607,7 @@ export { defineKeyDownHandler as defineKeyDownHandler_alias_1 }
 /**
  * @public
  */
-declare function defineKeymap(keymap: Keymap): Extension;
+declare function defineKeymap(keymap: Keymap): PlainExtension;
 export { defineKeymap }
 export { defineKeymap as defineKeymap_alias_1 }
 
@@ -586,7 +647,7 @@ export { defineMarkSpec as defineMarkSpec_alias_1 }
  *
  * @public
  */
-declare function defineMountHandler(handler: MountHandler): Extension<ExtensionTyping<any, any, any>>;
+declare function defineMountHandler(handler: MountHandler): PlainExtension;
 export { defineMountHandler }
 export { defineMountHandler as defineMountHandler_alias_1 }
 
@@ -671,7 +732,7 @@ export { definePasteHandler as definePasteHandler_alias_1 }
  */
 declare function definePlugin(plugin: Plugin_2 | Plugin_2[] | ((context: {
     schema: Schema;
-}) => Plugin_2 | Plugin_2[])): PluginExtension;
+}) => Plugin_2 | Plugin_2[])): PlainExtension;
 export { definePlugin }
 export { definePlugin as definePlugin_alias_1 }
 
@@ -687,29 +748,11 @@ export { defineScrollToSelectionHandler as defineScrollToSelectionHandler_alias_
 /**
  * @internal
  */
-export declare function defineTestExtension(): Union<readonly [BaseCommandsExtension, BaseKeymapExtension, DocExtension, HistoryExtension, Extension<{
-Nodes: {
-paragraph: Attrs_2;
-};
-}>, TextExtension, Extension<{
-Marks: {
-bold: Attrs_2;
-};
-}>, Extension<{
-Marks: {
-italic: Attrs_2;
-};
-}>, Extension<{
-Nodes: {
-heading: Attrs_2;
-};
-}>, Extension<{
+export declare function defineTestExtension(): Union<readonly [BaseCommandsExtension, PlainExtension, DocExtension, HistoryExtension, Extension<{
 Nodes: {
-codeBlock: {
-language: string;
+paragraph: Attrs;
 };
-};
-}>]>;
+}>, TextExtension, BoldExtension, ItalicExtension, LinkExtension, HeadingExtension, CodeBlockExtension]>;
 
 /**
  * @public
@@ -750,7 +793,7 @@ export { defineTripleClickOnHandler as defineTripleClickOnHandler_alias_1 }
  *
  * @public
  */
-declare function defineUnmountHandler(handler: UnmountHandler): Extension<ExtensionTyping<any, any, any>>;
+declare function defineUnmountHandler(handler: UnmountHandler): PlainExtension;
 export { defineUnmountHandler }
 export { defineUnmountHandler as defineUnmountHandler_alias_1 }
 
@@ -759,7 +802,7 @@ export { defineUnmountHandler as defineUnmountHandler_alias_1 }
  *
  * @public
  */
-declare function defineUpdateHandler(handler: UpdateHandler): Extension<ExtensionTyping<any, any, any>>;
+declare function defineUpdateHandler(handler: UpdateHandler): PlainExtension;
 export { defineUpdateHandler }
 export { defineUpdateHandler as defineUpdateHandler_alias_1 }
 
@@ -855,15 +898,10 @@ export { DropHandler as DropHandler_alias_1 }
  */
 declare class Editor<E extends Extension = any> {
     private instance;
-    private afterMounted;
     /**
      * @internal
      */
     constructor(instance: EditorInstance);
-    /**
-     * @internal
-     */
-    static create(instance: any): Editor<any>;
     /**
      * Whether the editor is mounted.
      */
@@ -876,6 +914,10 @@ declare class Editor<E extends Extension = any> {
      * The editor schema.
      */
     get schema(): Schema<ExtractNodeNames<E>, ExtractMarkNames<E>>;
+    /**
+     * The editor's current state.
+     */
+    get state(): EditorState;
     /**
      * Whether the editor is focused.
      */
@@ -884,28 +926,24 @@ declare class Editor<E extends Extension = any> {
      * Mount the editor to the given HTML element.
      * Pass `null` or `undefined` to unmount the editor.
      */
-    mount(place: HTMLElement | null | undefined): void;
+    mount: (place: HTMLElement | null | undefined) => void;
     /**
      * Unmount the editor. This is equivalent to `mount(null)`.
      */
-    unmount(): void;
+    unmount: () => void;
     /**
      * Focus the editor.
      */
-    focus(): void;
+    focus: () => void;
     /**
      * Blur the editor.
      */
-    blur(): void;
+    blur: () => void;
     /**
      * Register an extension to the editor. Return a function to unregister the
      * extension.
      */
-    use(extension: Extension): VoidFunction;
-    /**
-     * The editor's current state.
-     */
-    get state(): EditorState;
+    use: (extension: Extension) => VoidFunction;
     /**
      * Update the editor's state.
      *
@@ -914,7 +952,32 @@ declare class Editor<E extends Extension = any> {
      * This is an advanced method. Use it only if you have a specific reason to
      * directly manipulate the editor's state.
      */
-    updateState(state: EditorState): void;
+    updateState: (state: EditorState) => void;
+    /**
+     * Update the editor's document and selection.
+     *
+     * @param content - The new document to set. It can be one of the following:
+     *   - A ProseMirror node instance
+     *   - A ProseMirror node JSON object
+     *   - An HTML string
+     *   - An HTML element instance
+     * @param selection - Optional. Specifies the new selection. It can be one of the following:
+     *   - A ProseMirror selection instance
+     *   - A ProseMirror selection JSON object
+     *   - The string "start" (to set selection at the beginning, default value)
+     *   - The string "end" (to set selection at the end)
+     */
+    setContent: (content: ProseMirrorNode | NodeJSON | string | HTMLElement, selection?: SelectionJSON | Selection_2 | "start" | "end") => void;
+    /**
+     * Execute the given command. Return `true` if the command was successfully
+     * executed, otherwise `false`.
+     */
+    exec: (command: Command) => boolean;
+    /**
+     * Check if the given command can be executed. Return `true` if the command
+     * can be executed, otherwise `false`.
+     */
+    canExec: (command: Command) => boolean;
     /**
      * All {@link CommandAction}s defined by the editor.
      */
@@ -932,6 +995,8 @@ export { Editor }
 export { Editor as Editor_alias_1 }
 
 /**
+ * An internal class to make TypeScript generic type easier to use.
+ *
  * @internal
  */
 export declare class EditorInstance {
@@ -942,16 +1007,22 @@ export declare class EditorInstance {
     commands: Record<string, CommandAction>;
     private tree;
     private directEditorProps;
+    private afterMounted;
     constructor(extension: Extension);
     getState: () => EditorState;
     updateState(state: EditorState): void;
-    updateExtension(extension: Extension, add: boolean): void;
+    private dispatch;
+    setContent(content: NodeJSON | string | HTMLElement | ProseMirrorNode, selection?: SelectionJSON | Selection_2 | 'start' | 'end'): void;
+    private updateExtension;
+    use(extension: Extension): VoidFunction;
     mount(place: HTMLElement): void;
     unmount(): void;
     get mounted(): boolean;
     get assertView(): EditorView;
     definePlugins(plugins: readonly Plugin_2[]): void;
     removePlugins(plugins: readonly Plugin_2[]): void;
+    exec(command: Command): boolean;
+    canExec(command: Command): boolean;
     defineCommand<Args extends any[] = any[]>(name: string, commandCreator: CommandCreator<Args>): void;
     removeCommand(name: string): void;
 }
@@ -973,19 +1044,28 @@ declare interface EditorOptions<E extends Extension> {
      * The extension to use when creating the editor.
      */
     extension: E;
+    /**
+     * The starting document to use when creating the editor. It can be a
+     * ProseMirror node JSON object, a HTML string, or a HTML element instance.
+     */
+    defaultContent?: NodeJSON | string | HTMLElement;
     /**
      * A JSON object representing the starting document to use when creating the
      * editor.
+     *
+     * @deprecated Use `defaultContent` instead.
      */
     defaultDoc?: NodeJSON;
     /**
      * A HTML element or a HTML string representing the starting document to use
      * when creating the editor.
+     *
+     * @deprecated Use `defaultContent` instead.
      */
     defaultHTML?: string | HTMLElement;
     /**
      * A JSON object representing the starting selection to use when creating the
-     * editor. It's only used when `defaultDoc` or `defaultHTML` is also provided.
+     * editor. It's only used when `defaultContent` is also provided.
      */
     defaultSelection?: SelectionJSON;
 }
@@ -1190,7 +1270,7 @@ export declare class FacetExtensionImpl<Input, Output> extends BaseExtension {
     /**
      * @internal
      */
-    createTree(priority: Priority): FacetNode<any, any>;
+    createTree(priority: Priority): FacetNode;
 }
 
 export declare class FacetNode<I = any, O = any> {
@@ -1220,10 +1300,63 @@ export declare function findBrowserWindow(options?: {
     document?: Document;
 }): (Window & typeof globalThis) | null | undefined;
 
-export declare function findParentNode(nodeType: NodeType, $pos: ResolvedPos): {
-    from: number | null;
-    to: number | null;
-};
+/**
+ * Find the closest parent node that satisfies the predicate.
+ *
+ * @public
+ */
+declare function findParentNode(
+/**
+ * The predicate to test the parent node.
+ */
+predicate: (node: ProseMirrorNode) => boolean, 
+/**
+ * The position to start searching from.
+ */
+$pos: ResolvedPos): FindParentNodeResult | undefined;
+export { findParentNode }
+export { findParentNode as findParentNode_alias_1 }
+
+/**
+ * Finds the closest parent node that matches the given node type.
+ *
+ * @public
+ */
+declare function findParentNodeOfType(
+/**
+ * The type of the node to find.
+ */
+type: NodeType | string, 
+/**
+ * The position to start searching from.
+ */
+$pos: ResolvedPos): FindParentNodeResult | undefined;
+export { findParentNodeOfType }
+export { findParentNodeOfType as findParentNodeOfType_alias_1 }
+
+/**
+ * @public
+ */
+declare interface FindParentNodeResult {
+    /**
+     * The closest parent node that satisfies the predicate.
+     */
+    node: ProseMirrorNode;
+    /**
+     * The position directly before the node.
+     */
+    pos: number;
+    /**
+     * The position at the start of the node.
+     */
+    start: number;
+    /**
+     * The depth of the node.
+     */
+    depth: number;
+}
+export { FindParentNodeResult }
+export { FindParentNodeResult as FindParentNodeResult_alias_1 }
 
 /**
  * A function that is called when the editor gains or loses focus.
@@ -1246,6 +1379,14 @@ export declare function getBrowserWindow(options?: {
 
 export declare function getCustomSelection(state: EditorState, from?: number | null, to?: number | null): Selection_3;
 
+export declare function getEditorContentDoc(schema: Schema, content: NodeJSON | string | HTMLElement | ProseMirrorNode): ProseMirrorNode;
+
+export declare function getEditorContentJSON(schema: Schema, content: NodeJSON | string | HTMLElement): NodeJSON;
+
+export declare function getEditorContentNode(schema: Schema, content: NodeJSON | string | HTMLElement | ProseMirrorNode): ProseMirrorNode;
+
+export declare function getEditorSelection(doc: ProseMirrorNode, selection: SelectionJSON | Selection_2 | 'start' | 'end'): Selection_2;
+
 /**
  * Returns a unique id in the current process that can be used in various places.
  *
@@ -1274,11 +1415,19 @@ export { getNodeType as getNodeType_alias_1 }
  */
 export declare function getNodeTypes(schema: Schema, types: string | NodeType | string[] | NodeType[]): NodeType[];
 
-export declare type GroupedEntries<T extends Record<string, any>> = {
+declare type GetStateFunction = () => EditorState | null | undefined;
+
+export declare function groupBy<K extends PropertyKey, T>(items: Iterable<T>, keySelector: (item: T) => K): Partial<Record<K, T[]>>;
+
+export declare function groupEntries<T extends Record<string, any>>(entries: ObjectEntries<T>[]): {
     [K in keyof T]?: T[K][];
 };
 
-export declare function groupEntries<T extends Record<string, any>>(entries: ObjectEntries<T>[]): GroupedEntries<T>;
+declare type HeadingExtension = Extension<{
+    Nodes: {
+        heading: Attrs;
+    };
+}>;
 
 /**
  * @internal
@@ -1341,6 +1490,31 @@ export { htmlFromNode as htmlFromNode_alias_1 }
 
 export declare function includesMark(marks: readonly Mark[], markType: MarkType, attrs?: Attrs | null): boolean;
 
+export declare function inputText(input: string): Promise<void>;
+
+/**
+ * Returns a command that inserts a default block after current selection or at
+ * the given position.
+ *
+ * @public
+ */
+declare function insertDefaultBlock(options?: InsertDefaultBlockOptions): Command;
+export { insertDefaultBlock }
+export { insertDefaultBlock as insertDefaultBlock_alias_1 }
+
+/**
+ * @public
+ */
+declare interface InsertDefaultBlockOptions {
+    /**
+     * The position to insert the node at. By default it will insert after the
+     * current selection.
+     */
+    pos?: number;
+}
+export { InsertDefaultBlockOptions }
+export { InsertDefaultBlockOptions as InsertDefaultBlockOptions_alias_1 }
+
 /**
  * Returns a command that inserts the given node at the current selection or at
  * the given position.
@@ -1381,6 +1555,8 @@ declare interface InsertNodeOptions {
 export { InsertNodeOptions }
 export { InsertNodeOptions as InsertNodeOptions_alias_1 }
 
+export declare function insertOutputSpecAttrs(dom: DOMOutputSpec, attrs: Array<[key: string, value: string]>): DOMOutputSpec;
+
 /**
  * Returns a command that inserts the given text.
  *
@@ -1398,7 +1574,9 @@ export declare type InsertTextOptions = {
 };
 
 /**
- * @internal
+ * Checks if the given object is a `AllSelection` instance.
+ *
+ * @public
  */
 declare function isAllSelection(sel: Selection_2): sel is AllSelection;
 export { isAllSelection }
@@ -1420,7 +1598,16 @@ declare function isAtBlockStart(state: EditorState, view?: EditorView): Resolved
 export { isAtBlockStart }
 export { isAtBlockStart as isAtBlockStart_alias_1 }
 
-export declare function isElement(value: unknown): value is Element;
+export declare function isElement(el: unknown): el is Element;
+
+/**
+ * Checks if the given object is a `Fragment` instance.
+ *
+ * @public
+ */
+declare function isFragment(fragment: unknown): fragment is Fragment;
+export { isFragment }
+export { isFragment as isFragment_alias_1 }
 
 /**
  * Check if the selection is in a code block.
@@ -1432,7 +1619,9 @@ export { isInCodeBlock }
 export { isInCodeBlock as isInCodeBlock_alias_1 }
 
 /**
- * @internal
+ * Checks if the given object is a `Mark` instance.
+ *
+ * @public
  */
 declare function isMark(mark: unknown): mark is Mark;
 export { isMark }
@@ -1459,21 +1648,46 @@ export { isMarkActive as isMarkActive_alias_1 }
 export declare function isNodeActive(state: EditorState, type: string | NodeType, attrs?: Attrs | null): boolean;
 
 /**
- * @internal
+ * Checks if the given object is a `NodeSelection` instance.
+ *
+ * @public
  */
 declare function isNodeSelection(sel: Selection_2): sel is NodeSelection;
 export { isNodeSelection }
 export { isNodeSelection as isNodeSelection_alias_1 }
 
-export declare function isNotNull<T>(value: T | null | undefined): value is T;
-
 /**
  * @internal
  */
+export declare function isNotNullish<T>(value: T | null | undefined | void): value is T;
+
+export declare function isObject(v: unknown): v is Record<string, unknown>;
+
+/**
+ * Checks if the given object is a `ProseMirrorNode` instance.
+ */
 declare function isProseMirrorNode(node: unknown): node is ProseMirrorNode;
 export { isProseMirrorNode }
 export { isProseMirrorNode as isProseMirrorNode_alias_1 }
 
+/**
+ * Checks if the given object is a `Selection` instance.
+ *
+ * @public
+ */
+declare function isSelection(sel: unknown): sel is Selection_2;
+export { isSelection }
+export { isSelection as isSelection_alias_1 }
+
+/**
+ * Checks if the given object is a `Slice` instance.
+ *
+ * @public
+ */
+declare function isSlice(slice: unknown): slice is Slice;
+export { isSlice }
+export { isSlice as isSlice_alias_1 }
+
 /**
  * Check if `subset` is a subset of `superset`.
  *
@@ -1482,12 +1696,20 @@ export { isProseMirrorNode as isProseMirrorNode_alias_1 }
 export declare function isSubset(subset: Record<string, unknown>, superset: Record<string, unknown>): boolean;
 
 /**
- * @internal
+ * Checks if the given object is a `TextSelection` instance.
+ *
+ * @public
  */
 declare function isTextSelection(sel: Selection_2): sel is TextSelection;
 export { isTextSelection }
 export { isTextSelection as isTextSelection_alias_1 }
 
+declare type ItalicExtension = Extension<{
+    Marks: {
+        italic: Attrs;
+    };
+}>;
+
 /**
  * Serialize a HTML element to a ProseMirror document JSON object.
  *
@@ -1560,6 +1782,16 @@ declare type KeyPressHandler = (view: EditorView, event: KeyboardEvent) => boole
 export { KeyPressHandler }
 export { KeyPressHandler as KeyPressHandler_alias_1 }
 
+declare interface LinkAttrs {
+    href: string;
+}
+
+declare type LinkExtension = Extension<{
+    Marks: {
+        link: LinkAttrs;
+    };
+}>;
+
 /**
  * A function for creating a mark with optional attributes and any number of
  * children.
@@ -1595,13 +1827,18 @@ declare interface MarkAttrOptions<MarkName extends string = string, AttrName ext
      */
     attr: AttrName;
     /**
-     * Returns the attribute key and value to be set on the DOM node.
+     * Returns the attribute key and value to be set on the HTML element.
+     *
+     * If the returned `key` is `"style"`, the value is a string of CSS properties and will
+     * be prepended to the existing `style` attribute on the DOM node.
+     *
+     * @param value - The value of the attribute of current ProseMirror node.
      */
-    toDOM?: (value: any) => [key: string, value: string] | null | void;
+    toDOM?: (value: AttrType) => [key: string, value: string] | null | undefined;
     /**
      * Parses the attribute value from the DOM.
      */
-    parseDOM?: (node: HTMLElement) => any;
+    parseDOM?: (node: HTMLElement) => AttrType;
 }
 export { MarkAttrOptions }
 export { MarkAttrOptions as MarkAttrOptions_alias_1 }
@@ -1647,6 +1884,12 @@ declare function maybeRun<T, R = T extends (...args: any[]) => void ? ReturnType
 export { maybeRun }
 export { maybeRun as maybeRun_alias_1 }
 
+export declare function mergeObjects<T extends object>(...objects: Array<Partial<T> | null | undefined>): Partial<T>;
+
+export declare function mergeSpecs(a: NodeSpec, b: NodeSpec): NodeSpec;
+
+export declare function mergeSpecs(a: MarkSpec, b: MarkSpec): MarkSpec;
+
 /**
  * A function that is called when the editor view is mounted.
  *
@@ -1701,16 +1944,18 @@ declare interface NodeAttrOptions<NodeName extends string = string, AttrName ext
      */
     splittable?: boolean;
     /**
-     * Returns the attribute key and value to be set on the DOM node.
+     * Returns the attribute key and value to be set on the HTML element.
      *
-     * If the `key` is `"style"`, the value is a string of CSS properties and will
+     * If the returned `key` is `"style"`, the value is a string of CSS properties and will
      * be prepended to the existing `style` attribute on the DOM node.
+     *
+     * @param value - The value of the attribute of current ProseMirror node.
      */
-    toDOM?: (value: any) => [key: string, value: string] | null | void;
+    toDOM?: (value: AttrType) => [key: string, value: string] | null | undefined;
     /**
      * Parses the attribute value from the DOM.
      */
-    parseDOM?: (node: HTMLElement) => any;
+    parseDOM?: (node: HTMLElement) => AttrType;
 }
 export { NodeAttrOptions }
 export { NodeAttrOptions as NodeAttrOptions_alias_1 }
@@ -1733,6 +1978,8 @@ export { NodeChild as NodeChild_alias_1 }
 
 /**
  * @public
+ *
+ * @deprecated
  */
 declare type NodeContent = ProseMirrorNode | ProseMirrorFragment | NodeContent[];
 export { NodeContent }
@@ -1772,7 +2019,10 @@ export { nodeFromJSON as nodeFromJSON_alias_1 }
  */
 declare interface NodeJSON {
     type: string;
-    marks?: Array<any>;
+    marks?: Array<{
+        type: string;
+        attrs?: Record<string, any>;
+    }>;
     text?: string;
     content?: NodeJSON[];
     attrs?: Record<string, any>;
@@ -1902,15 +2152,17 @@ export { PickSubType }
 export { PickSubType as PickSubType_alias_1 }
 
 /**
+ * An extension that does not define any nodes, marks, or commands.
+ *
  * @internal
  */
-declare type PluginExtension = Extension<{
+declare type PlainExtension = Extension<{
     Nodes: never;
     Marks: never;
     Commands: never;
 }>;
-export { PluginExtension }
-export { PluginExtension as PluginExtension_alias_1 }
+export { PlainExtension }
+export { PlainExtension as PlainExtension_alias_1 }
 
 /**
  * @internal
@@ -2004,13 +2256,16 @@ declare interface RemoveNodeOptions {
      */
     type: string | NodeType;
     /**
-     * The document position to start searching node. By default it will be the anchor position of current selection.
+     * The document position to start searching node. By default it will be the
+     * anchor position of current selection.
      */
     pos?: number;
 }
 export { RemoveNodeOptions }
 export { RemoveNodeOptions as RemoveNodeOptions_alias_1 }
 
+export declare function removeUndefinedValues<T extends object>(obj: T): T;
+
 export declare const rootFacet: Facet<RootPayload, RootOutput>;
 
 export declare type RootOutput = {
@@ -2127,29 +2382,11 @@ export declare function setupEditorExtension<E extends Extension>(options: Edito
  * @internal
  */
 export declare function setupTest(): {
-    editor: TestEditor<Union<readonly [BaseCommandsExtension, BaseKeymapExtension, DocExtension, HistoryExtension, Extension<{
+    editor: TestEditor<Union<readonly [BaseCommandsExtension, PlainExtension, DocExtension, HistoryExtension, Extension<{
     Nodes: {
-    paragraph: Attrs_2;
-    };
-    }>, TextExtension, Extension<{
-    Marks: {
-    bold: Attrs_2;
+    paragraph: Attrs;
     };
-    }>, Extension<{
-    Marks: {
-    italic: Attrs_2;
-    };
-    }>, Extension<{
-    Nodes: {
-    heading: Attrs_2;
-    };
-    }>, Extension<{
-    Nodes: {
-    codeBlock: {
-    language: string;
-    };
-    };
-    }>]>>;
+    }>, TextExtension, BoldExtension, ItalicExtension, LinkExtension, HeadingExtension, CodeBlockExtension]>>;
     m: ToMarkAction<SimplifyDeeper<    {
     bold: {
     readonly [x: string]: any;
@@ -2157,6 +2394,9 @@ export declare function setupTest(): {
     italic: {
     readonly [x: string]: any;
     };
+    link: {
+    href: string;
+    };
     }>>;
     n: {
         p: NodeAction<    {
@@ -2171,12 +2411,12 @@ export declare function setupTest(): {
         text: NodeAction<    {
         readonly [x: string]: any;
         }>;
-        codeBlock: NodeAction<    {
-        language: string;
-        }>;
         heading: NodeAction<    {
         readonly [x: string]: any;
         }>;
+        codeBlock: NodeAction<    {
+        language: string;
+        }>;
     };
 };
 
@@ -2320,9 +2560,11 @@ export declare type ToCommandCreators<T extends CommandTyping> = {
 /**
  * Returns a command that toggles the given mark with the given attributes.
  *
+ * @param options
+ *
  * @public
  */
-declare function toggleMark({ type, attrs }: ToggleMarkOptions): Command;
+declare function toggleMark({ type, attrs, removeWhenPresent, enterInlineAtoms, }: ToggleMarkOptions): Command;
 export { toggleMark }
 export { toggleMark as toggleMark_alias_1 }
 
@@ -2330,8 +2572,30 @@ export { toggleMark as toggleMark_alias_1 }
  * @public
  */
 declare interface ToggleMarkOptions {
+    /**
+     * The mark type to toggle.
+     */
     type: string | MarkType;
+    /**
+     * The optional attributes to set on the mark.
+     */
     attrs?: Attrs | null;
+    /**
+     * Controls whether, when part of the selected range has the mark
+     * already and part doesn't, the mark is removed (`true`) or added
+     * (`false`).
+     *
+     * @default false
+     */
+    removeWhenPresent?: boolean;
+    /**
+     * Whether the command should act on the content of inline nodes marked as
+     * [atoms](https://prosemirror.net/docs/ref/#model.NodeSpec.atom) that are
+     * completely covered by a selection range.
+     *
+     * @default true
+     */
+    enterInlineAtoms?: boolean;
 }
 export { ToggleMarkOptions }
 export { ToggleMarkOptions as ToggleMarkOptions_alias_1 }
@@ -2340,6 +2604,8 @@ export { ToggleMarkOptions as ToggleMarkOptions_alias_1 }
  * Returns a command that set the selected textblocks to the given node type
  * with the given attributes.
  *
+ * @param options
+ *
  * @public
  */
 declare function toggleNode({ type, attrs }: ToggleNodeOptions): Command;
@@ -2407,7 +2673,8 @@ export { Union }
 export { Union as Union_alias_1 }
 
 /**
- * Merge multiple extensions into one.
+ * Merges multiple extensions into one. You can pass multiple extensions as
+ * arguments or a single array containing multiple extensions.
  *
  * @throws If no extensions are provided.
  *
@@ -2415,6 +2682,17 @@ export { Union as Union_alias_1 }
  *
  * ```ts
  * function defineFancyNodes() {
+ *   return union(
+ *     defineFancyParagraph(),
+ *     defineFancyHeading(),
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * function defineFancyNodes() {
  *   return union([
  *     defineFancyParagraph(),
  *     defineFancyHeading(),
@@ -2570,12 +2848,13 @@ export { withSkipCodeBlock }
 export { withSkipCodeBlock as withSkipCodeBlock_alias_1 }
 
 /**
- * Returns a command that wraps the selected textblock with the given node type
- * with the given attributes.
+ * Returns a command that wraps the selected textblock with the given node type.
+ *
+ * @param options
  *
  * @public
  */
-declare function wrap({ nodeType, attrs }: WrapOptions): Command;
+declare function wrap(options: WrapOptions): Command;
 export { wrap }
 export { wrap as wrap_alias_1 }
 
@@ -2583,12 +2862,26 @@ export { wrap as wrap_alias_1 }
  * @public
  */
 declare interface WrapOptions {
-    nodeType: NodeType;
+    /**
+     * The node type to wrap the selected textblock with.
+     */
+    type: NodeType | string;
+    /**
+     * @deprecated Use `nodeSpec` instead.
+     */
+    nodeType?: NodeType;
+    /**
+     * Optional attributes to apply to the node.
+     */
     attrs?: Attrs | null;
 }
 export { WrapOptions }
 export { WrapOptions as WrapOptions_alias_1 }
 
+export declare function wrapOutputSpecAttrs<T extends ProseMirrorNode | Mark, Args extends readonly unknown[]>(toDOM: (node: T, ...args: Args) => DOMOutputSpec, options: AttrOptions[]): (node: T, ...args: Args) => DOMOutputSpec;
+
+export declare function wrapTagParseRuleAttrs(rule: TagParseRule, options: AttrOptions[]): TagParseRule;
+
 export declare function zip<T, P>(a: T[], b: P[]): [T, P][];
 
 export { }