@prosekit/core 0.0.0-next-20231120040948 → 0.0.0-next-20240421132240

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

@@ -3,22 +3,27 @@ import { Attrs } from '@prosekit/pm/model';
 import { Attrs as Attrs_2 } from 'prosemirror-model';
 import { Command } from '@prosekit/pm/state';
 import type { ConditionalExcept } from 'type-fest';
+import type { ContentMatch } from '@prosekit/pm/model';
 import type { DirectEditorProps } from '@prosekit/pm/view';
+import type { DOMEventMap } from '@prosekit/pm/view';
+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 type { EmptyObject } from 'type-fest';
-import { InputRule } from '@prosekit/pm/inputrules';
 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 { MarkType as MarkType_2 } from 'prosemirror-model';
 import { Node as Node_2 } from 'prosemirror-model';
+import type { Node as Node_3 } from '@prosekit/pm/model';
 import { NodeSelection } from '@prosekit/pm/state';
 import type { NodeSpec } from '@prosekit/pm/model';
 import { NodeType } from '@prosekit/pm/model';
 import { NodeType as NodeType_2 } from 'prosemirror-model';
+import { NodeView } from '@prosekit/pm/view';
 import { NodeViewConstructor } from '@prosekit/pm/view';
 import { Options } from 'tsup';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
@@ -29,10 +34,10 @@ import type { 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 { TextSelection } from '@prosekit/pm/state';
 import { Transaction } from '@prosekit/pm/state';
 import type { UnionToIntersection } from 'type-fest';
-import { UserProjectConfigExport } from 'vitest/dist/config.js';
 
 declare type Action = (options: {
     tr: Transaction;
@@ -40,7 +45,9 @@ declare type Action = (options: {
 }) => boolean;
 
 /**
- * Add the given mark to the inline content.
+ * Returns a command that adds the given mark with the given attributes.
+ *
+ * @public
  */
 declare function addMark(options: {
     /**
@@ -94,8 +101,55 @@ export declare abstract class BaseExtension<T extends ExtensionTyping = Extensio
     abstract schema: Schema | null;
 }
 
+/**
+ * Some basic props for custom node views.
+ *
+ * @public
+ */
+declare interface BaseNodeViewOptions {
+    /**
+     * The wrapping DOM element for the node view. Defaults to `div` for block nodes and `span` for inline nodes.
+     */
+    as?: string | HTMLElement | ((node: ProseMirrorNode) => HTMLElement);
+    /**
+     * The wrapping DOM element for the node view's content. Defaults to `div` for block nodes and `span` for inline nodes.
+     */
+    contentAs?: string | HTMLElement | ((node: ProseMirrorNode) => HTMLElement);
+    update?: NodeView['update'];
+    ignoreMutation?: NodeView['ignoreMutation'];
+    selectNode?: NodeView['selectNode'];
+    deselectNode?: NodeView['deselectNode'];
+    setSelection?: NodeView['setSelection'];
+    stopEvent?: NodeView['stopEvent'];
+    destroy?: NodeView['destroy'];
+    onUpdate?: () => void;
+}
+export { BaseNodeViewOptions }
+export { BaseNodeViewOptions as BaseNodeViewOptions_alias_1 }
+
+declare type ClickHandler = (view: EditorView, pos: number, event: MouseEvent) => boolean | void;
+export { ClickHandler }
+export { ClickHandler as ClickHandler_alias_1 }
+
+declare type ClickOnHandler = (view: EditorView, pos: number, node: Node_3, nodePos: number, event: MouseEvent, direct: boolean) => boolean | void;
+export { ClickOnHandler }
+export { ClickOnHandler as ClickOnHandler_alias_1 }
+
+/**
+ * A utility for constructing `className` strings conditionally.
+ *
+ * It is a re-export of [clsx/lite](https://www.npmjs.com/package/clsx) with stricter types.
+ *
+ * @public
+ */
+declare const clsx: (...args: Array<string | boolean | null | undefined>) => string;
+export { clsx }
+export { clsx as clsx_alias_1 }
+
 export declare function collectNodes(content: NodeContent): ProseMirrorNode[];
 
+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 interface CommandApplier<Args extends any[] = any[]> {
     (...args: Args): boolean;
     canApply(...args: Args): boolean;
@@ -127,7 +181,7 @@ declare type ConverterTuple = Tuple5<FacetConverter | undefined>;
 /**
  * @public
  */
-declare function createEditor<E extends Extension>({ extension, defaultDoc, defaultHTML, defaultSelection, }: EditorOptions<E>): Editor<E>;
+declare function createEditor<E extends Extension>(options: EditorOptions<E>): Editor<E>;
 export { createEditor }
 export { createEditor as createEditor_alias_1 }
 
@@ -137,7 +191,18 @@ export declare function createNodeBuilder(getState: () => EditorState | null | u
 
 export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
 
-export declare const default_alias_1: UserProjectConfigExport;
+export declare const default_alias_1: {
+    test: {
+        environment: "jsdom";
+    };
+};
+
+/**
+ * @internal
+ */
+declare function defaultBlockAt(match: ContentMatch): NodeType_2 | null;
+export { defaultBlockAt }
+export { defaultBlockAt as defaultBlockAt_alias_1 }
 
 declare interface DefaultStateOptions {
     /**
@@ -192,6 +257,11 @@ declare function defineBaseCommands(): Extension<{
             from?: number | undefined;
             to?: number | undefined;
         }];
+        setNodeAttrs: [options: {
+            type: string | NodeType_2;
+            attrs: Attrs_2;
+            pos?: number | undefined;
+        }];
         selectAll: [];
         addMark: [options: {
             type: string | MarkType_2;
@@ -211,12 +281,39 @@ export { defineBaseCommands }
 export { defineBaseCommands as defineBaseCommands_alias_1 }
 
 /**
+ * Defines some basic key bindings.
+ *
  * @public
  */
-declare function defineBaseKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineBaseKeymap(options?: {
+    /**
+     * The priority of the keymap.
+     *
+     * @default Priority.low
+     */
+    priority?: Priority;
+}): Extension<ExtensionTyping<string, string, CommandArgs>>;
 export { defineBaseKeymap }
 export { defineBaseKeymap as defineBaseKeymap_alias_1 }
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleClick}
+ */
+declare function defineClickHandler(handler: ClickHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineClickHandler }
+export { defineClickHandler as defineClickHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleClickOn}
+ */
+declare function defineClickOnHandler(handler: ClickOnHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineClickOnHandler }
+export { defineClickOnHandler as defineClickOnHandler_alias_1 }
+
 declare function defineCommands<T extends Record<string, CommandCreator> = Record<string, CommandCreator>>(commands: T): Extension<{
     COMMAND_ARGS: {
         [K in keyof T]: Parameters<T[K]>;
@@ -238,6 +335,60 @@ NODES: "doc";
 export { defineDoc }
 export { defineDoc as defineDoc_alias_1 }
 
+/**
+ * Registers a event handler that is called when the editor document is changed.
+ *
+ * @public
+ */
+declare function defineDocChangeHandler(handler: DocChangeHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineDocChangeHandler }
+export { defineDocChangeHandler as defineDocChangeHandler_alias_1 }
+
+/**
+ * Register a new event handler for the given event type.
+ *
+ * @public
+ */
+declare function defineDOMEventHandler<Event extends keyof DOMEventMap = string>(event: Event, handler: DOMEventHandler<Event>): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineDOMEventHandler }
+export { defineDOMEventHandler as defineDOMEventHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleDoubleClick}
+ */
+declare function defineDoubleClickHandler(handler: DoubleClickHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineDoubleClickHandler }
+export { defineDoubleClickHandler as defineDoubleClickHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleDoubleClickOn}
+ */
+declare function defineDoubleClickOnHandler(handler: DoubleClickOnHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineDoubleClickOnHandler }
+export { defineDoubleClickOnHandler as defineDoubleClickOnHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleDrop}
+ */
+declare function defineDropHandler(handler: DropHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineDropHandler }
+export { defineDropHandler as defineDropHandler_alias_1 }
+
+/**
+ * Registers a event handler that is called when the editor gains or loses focus.
+ *
+ * @public
+ */
+declare function defineFocusChangeHandler(handler: FocusChangeHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineFocusChangeHandler }
+export { defineFocusChangeHandler as defineFocusChangeHandler_alias_1 }
+
 /**
  * Add undo/redo history to the editor.
  */
@@ -251,18 +402,13 @@ export { defineHistory }
 export { defineHistory as defineHistory_alias_1 }
 
 /**
- * Defines an input rule extension.
- *
- * @param rule - The ProseMirror input rule to add, or an array of input rules,
- * or a function that returns one or multiple input rules.
- *
  * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleKeyDown}
  */
-declare function defineInputRule(rule: InputRule | InputRule[] | ((context: {
-    schema: Schema;
-}) => InputRule | InputRule[])): Extension;
-export { defineInputRule }
-export { defineInputRule as defineInputRule_alias_1 }
+declare function defineKeyDownHandler(handler: KeyDownHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineKeyDownHandler }
+export { defineKeyDownHandler as defineKeyDownHandler_alias_1 }
 
 /**
  * @public
@@ -271,6 +417,22 @@ declare function defineKeymap(keymap: Keymap): Extension;
 export { defineKeymap }
 export { defineKeymap as defineKeymap_alias_1 }
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleKeyPress}
+ */
+declare function defineKeyPressHandler(handler: KeyPressHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineKeyPressHandler }
+export { defineKeyPressHandler as defineKeyPressHandler_alias_1 }
+
+/**
+ * @public
+ */
+declare function defineMarkAttr(options: MarkAttrOptions): Extension;
+export { defineMarkAttr }
+export { defineMarkAttr as defineMarkAttr_alias_1 }
+
 /**
  * @public
  */
@@ -281,6 +443,26 @@ export { defineMarkSpec }
 export { defineMarkSpec as defineMarkSpec_alias_1 }
 
 /**
+ * Registers a event handler that is called when the editor view is mounted.
+ *
+ * @public
+ */
+declare function defineMountHandler(handler: MountHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineMountHandler }
+export { defineMountHandler as defineMountHandler_alias_1 }
+
+/**
+ * Defines an attribute for a node type.
+ *
+ * @public
+ */
+declare function defineNodeAttr(options: NodeAttrOptions): Extension;
+export { defineNodeAttr }
+export { defineNodeAttr as defineNodeAttr_alias_1 }
+
+/**
+ * Defines a node type.
+ *
  * @public
  */
 declare function defineNodeSpec<NodeName extends string>(options: NodeSpecOptions<NodeName>): Extension<{
@@ -293,9 +475,12 @@ declare function defineNodeView(options: NodeViewOptions): Extension;
 export { defineNodeView }
 export { defineNodeView as defineNodeView_alias_1 }
 
-declare function defineNodeViewEffect(options: NodeViewEffectOptions): Extension;
-export { defineNodeViewEffect }
-export { defineNodeViewEffect as defineNodeViewEffect_alias_1 }
+/**
+ * @internal
+ */
+declare function defineNodeViewFactory<T>(options: NodeViewFactoryOptions<T>): Extension;
+export { defineNodeViewFactory }
+export { defineNodeViewFactory as defineNodeViewFactory_alias_1 }
 
 /**
  * @public
@@ -317,6 +502,15 @@ export declare function defineParagraphSpec(): Extension<    {
 NODES: "paragraph";
 }>;
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handlePaste}
+ */
+declare function definePasteHandler(handler: PasteHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { definePasteHandler }
+export { definePasteHandler as definePasteHandler_alias_1 }
+
 /**
  * Adds a ProseMirror plugin to the editor.
  *
@@ -331,6 +525,15 @@ declare function definePlugin(plugin: Plugin_2 | Plugin_2[] | ((context: {
 export { definePlugin }
 export { definePlugin as definePlugin_alias_1 }
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleScrollToSelection}
+ */
+declare function defineScrollToSelectionHandler(handler: ScrollToSelectionHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineScrollToSelectionHandler }
+export { defineScrollToSelectionHandler as defineScrollToSelectionHandler_alias_1 }
+
 /**
  * @public
  */
@@ -341,12 +544,126 @@ export { defineText }
 export { defineText as defineText_alias_1 }
 
 /**
- * @internal
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleTextInput}
+ */
+declare function defineTextInputHandler(handler: TextInputHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineTextInputHandler }
+export { defineTextInputHandler as defineTextInputHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleTripleClick}
+ */
+declare function defineTripleClickHandler(handler: TripleClickHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineTripleClickHandler }
+export { defineTripleClickHandler as defineTripleClickHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleTripleClickOn}
+ */
+declare function defineTripleClickOnHandler(handler: TripleClickOnHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineTripleClickOnHandler }
+export { defineTripleClickOnHandler as defineTripleClickOnHandler_alias_1 }
+
+/**
+ * Registers a event handler that is called when the editor view is unmounted.
+ *
+ * @public
+ */
+declare function defineUnmountHandler(handler: UnmountHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineUnmountHandler }
+export { defineUnmountHandler as defineUnmountHandler_alias_1 }
+
+/**
+ * Registers a event handler that is called when the editor state is updated.
+ *
+ * @public
  */
 declare function defineUpdateHandler(handler: UpdateHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
 export { defineUpdateHandler }
 export { defineUpdateHandler as defineUpdateHandler_alias_1 }
 
+/**
+ * A function that is called when the editor document is changed.
+ *
+ * @param view - The editor view.
+ * @param prevState - The previous editor state.
+ *
+ * @public
+ */
+declare type DocChangeHandler = (view: EditorView, prevState: EditorState) => void;
+export { DocChangeHandler }
+export { DocChangeHandler as DocChangeHandler_alias_1 }
+
+/**
+ * @internal
+ */
+export declare class DOMDocumentNotFoundError extends ProseKitError {
+    constructor();
+}
+
+/** @public */
+declare type DOMDocumentOptions = {
+    document?: Document;
+};
+export { DOMDocumentOptions }
+export { DOMDocumentOptions as DOMDocumentOptions_alias_1 }
+
+/**
+ * @internal
+ */
+export declare const domEventFacet: Facet<DOMEventPayload, PluginPayload>;
+
+/**
+ * A function to handle the events fired on the editable DOM element. Returns
+ * `true` to indicate that it handled the given event. you are responsible for
+ * calling `preventDefault` yourself (or not, if you want to allow the default
+ * behavior).
+ *
+ * @public
+ */
+declare type DOMEventHandler<Event extends keyof DOMEventMap = string> = (view: EditorView, event: DOMEventMap[Event]) => boolean | void;
+export { DOMEventHandler }
+export { DOMEventHandler as DOMEventHandler_alias_1 }
+
+/**
+ * @internal
+ */
+export declare type DOMEventPayload = [event: string, handler: DOMEventHandler];
+
+export declare type DOMNode = InstanceType<typeof window.Node>;
+
+/** @public */
+declare type DOMParserOptions = {
+    DOMParser?: typeof DOMParser_2;
+};
+export { DOMParserOptions }
+export { DOMParserOptions as DOMParserOptions_alias_1 }
+
+/** @public */
+declare type DOMSerializerOptions = {
+    DOMSerializer?: typeof DOMSerializer;
+};
+export { DOMSerializerOptions }
+export { DOMSerializerOptions as DOMSerializerOptions_alias_1 }
+
+declare type DoubleClickHandler = (view: EditorView, pos: number, event: MouseEvent) => boolean | void;
+export { DoubleClickHandler }
+export { DoubleClickHandler as DoubleClickHandler_alias_1 }
+
+declare type DoubleClickOnHandler = (view: EditorView, pos: number, node: Node_3, nodePos: number, event: MouseEvent, direct: boolean) => boolean | void;
+export { DoubleClickOnHandler }
+export { DoubleClickOnHandler as DoubleClickOnHandler_alias_1 }
+
+declare type DropHandler = (view: EditorView, event: DragEvent, slice: Slice, moved: boolean) => boolean | void;
+export { DropHandler }
+export { DropHandler as DropHandler_alias_1 }
+
 /**
  * @public
  */
@@ -358,27 +675,57 @@ declare class Editor<E extends Extension = any> {
      * @internal
      */
     static create(instance: any): Editor<any>;
+    /**
+     * Whether the editor is mounted.
+     */
     get mounted(): boolean;
+    /**
+     * The editor view.
+     */
     get view(): EditorView;
+    /**
+     * The editor schema.
+     */
     get schema(): Schema<ExtractNodes<E>, ExtractMarks<E>>;
     get commands(): ExtractCommandAppliers<E>;
-    mount(place: HTMLElement | null | undefined | void): void;
+    /**
+     * Whether the editor is focused.
+     */
+    get focused(): boolean;
+    /**
+     * Mount the editor to the given HTML element.
+     * Pass `null` or `undefined` to unmount the editor.
+     */
+    mount(place: HTMLElement | null | undefined): void;
+    /**
+     * Unmount the editor. This is equivalent to `mount(null)`.
+     */
     unmount(): void;
-    use(extension: Extension): VoidFunction;
     /**
-     * @deprecated
+     * Focus the editor.
      */
-    isNodeActive(nodeType: string | NodeType, attrs?: Attrs): boolean;
+    focus(): void;
     /**
-     * @deprecated
+     * Blur the editor.
      */
-    isMarkActive(markType: string | MarkType, attrs?: Attrs): boolean;
+    blur(): void;
+    use(extension: Extension): VoidFunction;
+    get state(): EditorState;
     get nodes(): Record<ExtractNodes<E>, NodeBuilder>;
     get marks(): Record<ExtractMarks<E>, MarkBuilder>;
 }
 export { Editor }
 export { Editor as Editor_alias_1 }
 
+/**
+ * @internal
+ */
+declare class EditorNotFoundError extends ProseKitError {
+    constructor();
+}
+export { EditorNotFoundError }
+export { EditorNotFoundError as EditorNotFoundError_alias_1 }
+
 /**
  * @public
  */
@@ -411,12 +758,44 @@ export { EditorOptions as EditorOptions_alias_1 }
  *
  * @internal
  */
-export declare function elementFromHTML(html: string): HTMLElement;
+export declare function elementFromHTML(html: string, options?: DOMDocumentOptions): HTMLElement;
+
+/**
+ * Parse a ProseMirror document JSON object to a HTML element.
+ *
+ * @public
+ */
+declare function elementFromJSON(json: NodeJSON, options: JSONParserOptions & DOMSerializerOptions & DOMDocumentOptions): HTMLElement;
+export { elementFromJSON }
+export { elementFromJSON as elementFromJSON_alias_1 }
+
+/**
+ * Serialize a ProseMirror node to a HTML element.
+ *
+ * @public
+ */
+declare function elementFromNode(node: ProseMirrorNode, options?: DOMSerializerOptions & DOMDocumentOptions): HTMLElement;
+export { elementFromNode }
+export { elementFromNode as elementFromNode_alias_1 }
 
 declare type EmptyValue = undefined | null | EmptyObject;
 
 export declare type ExceptEmptyValue<T> = ConditionalExcept<T, EmptyValue>;
 
+/**
+ * Expands the selection to include the entire mark at the current position.
+ *
+ * @public
+ */
+declare function expandMark(options: {
+    /**
+     * The type of the mark to expand.
+     */
+    type: string | MarkType;
+}): Command;
+export { expandMark }
+export { expandMark as expandMark_alias_1 }
+
 /**
  * @public
  */
@@ -561,14 +940,46 @@ declare interface FacetOptions<Input, Output> {
 export { FacetOptions }
 export { FacetOptions as FacetOptions_alias_1 }
 
-export declare function getBrowserDocument(): Document | undefined;
+export declare function findBrowserDocument(options?: {
+    document?: Document;
+}): Document | undefined;
+
+export declare function findBrowserWindow(options?: {
+    document?: Document;
+}): (Window & typeof globalThis) | null | undefined;
+
+/**
+ * A function that is called when the editor gains or loses focus.
+ *
+ * @param hasFocus - Whether the editor has focus.
+ *
+ * @public
+ */
+declare type FocusChangeHandler = (hasFocus: boolean) => void;
+export { FocusChangeHandler }
+export { FocusChangeHandler as FocusChangeHandler_alias_1 }
+
+export declare function getBrowserDocument(options?: {
+    document?: Document;
+}): Document;
 
-export declare function getBrowserWindow(): (Window & typeof globalThis) | null | undefined;
+export declare function getBrowserWindow(options?: {
+    document?: Document;
+}): Window & typeof globalThis;
 
 export declare function getCustomSelection(state: EditorState, from?: number | null, to?: number | null): Selection_3;
 
 export declare function getFacetCount(): number;
 
+/**
+ * Returns a unique id in the current process that can be used in various places.
+ *
+ * @internal
+ */
+declare function getId(): string;
+export { getId as _getId }
+export { getId }
+
 /**
  * @internal
  */
@@ -583,6 +994,41 @@ declare function getNodeType(schema: Schema, type: string | NodeType): NodeType;
 export { getNodeType }
 export { getNodeType as getNodeType_alias_1 }
 
+export declare type GroupedEntries<T extends Record<string, any>> = {
+    [K in keyof T]?: T[K][];
+};
+
+export declare function groupEntries<T extends Record<string, any>>(entries: ObjectEntries<T>[]): GroupedEntries<T>;
+
+/**
+ * @internal
+ */
+export declare function htmlFromElement(element: HTMLElement): string;
+
+/**
+ * Parse a ProseMirror document JSON object to a HTML string.
+ *
+ * @public
+ */
+declare function htmlFromJSON(json: NodeJSON, options: JSONParserOptions & DOMSerializerOptions & DOMDocumentOptions): string;
+export { htmlFromJSON }
+export { htmlFromJSON as htmlFromJSON_alias_1 }
+
+/**
+ * Serialize a ProseMirror node to a HTML string
+ *
+ * @public
+ */
+declare function htmlFromNode(node: ProseMirrorNode, options?: DOMSerializerOptions & DOMDocumentOptions): string;
+export { htmlFromNode }
+export { htmlFromNode as htmlFromNode_alias_1 }
+
+/**
+ * Returns a command that inserts the given node at the current selection or at
+ * the given position.
+ *
+ * @public
+ */
 declare function insertNode(options: {
     node: ProseMirrorNode;
     pos?: number;
@@ -602,6 +1048,11 @@ export declare function insertNodeAction({ node, pos, }: {
     pos?: number;
 }): Action;
 
+/**
+ * Returns a command that inserts the given text.
+ *
+ * @public
+ */
 export declare function insertText({ text, from, to, }: {
     text: string;
     from?: number;
@@ -615,6 +1066,17 @@ declare function isAllSelection(sel: Selection_2): sel is AllSelection;
 export { isAllSelection }
 export { isAllSelection as isAllSelection_alias_1 }
 
+export declare function isElement(value: unknown): value is Element;
+
+/**
+ * Check if the selection is in a code block.
+ *
+ * @internal
+ */
+declare function isInCodeBlock(selection: Selection_2): boolean | undefined;
+export { isInCodeBlock }
+export { isInCodeBlock as isInCodeBlock_alias_1 }
+
 export declare const isMac: boolean;
 
 /**
@@ -624,6 +1086,9 @@ declare function isMark(mark: unknown): mark is Mark;
 export { isMark }
 export { isMark as isMark_alias_1 }
 
+/**
+ * @internal
+ */
 export declare function isMarkActive(state: EditorState, type: string | MarkType, attrs?: Attrs | null): boolean;
 
 export declare function isNodeActive(state: EditorState, type: string | NodeType, attrs?: Attrs | null): boolean;
@@ -652,20 +1117,18 @@ export { isTextSelection }
 export { isTextSelection as isTextSelection_alias_1 }
 
 /**
- * Parse a HTML element to a ProseMirror document JSON.
+ * Serialize a HTML element to a ProseMirror document JSON object.
  *
  * @public
  */
-declare function jsonFromElement(element: HTMLElement, schema: Schema): NodeJSON;
-export { jsonFromElement }
-export { jsonFromElement as jsonFromElement_alias_1 }
+export declare function jsonFromElement(element: DOMNode, options: DOMParserOptions & JSONParserOptions): NodeJSON;
 
 /**
- * Parse a HTML string to a ProseMirror document JSON.
+ * Parse a HTML string to a ProseMirror document JSON object.
  *
  * @public
  */
-declare function jsonFromHTML(html: string, schema: Schema): NodeJSON;
+declare function jsonFromHTML(html: string, options: DOMDocumentOptions & DOMParserOptions & JSONParserOptions): NodeJSON;
 export { jsonFromHTML }
 export { jsonFromHTML as jsonFromHTML_alias_1 }
 
@@ -687,6 +1150,17 @@ declare function jsonFromState(state: EditorState): StateJSON;
 export { jsonFromState }
 export { jsonFromState as jsonFromState_alias_1 }
 
+/** @public */
+declare type JSONParserOptions = {
+    schema: Schema;
+};
+export { JSONParserOptions }
+export { JSONParserOptions as JSONParserOptions_alias_1 }
+
+declare type KeyDownHandler = (view: EditorView, event: KeyboardEvent) => boolean | void;
+export { KeyDownHandler }
+export { KeyDownHandler as KeyDownHandler_alias_1 }
+
 /**
  * @public
  */
@@ -696,6 +1170,54 @@ declare interface Keymap {
 export { Keymap }
 export { Keymap as Keymap_alias_1 }
 
+/**
+ * @internal
+ */
+declare const keymapFacet: Facet<Keymap, PluginPayload>;
+export { keymapFacet }
+export { keymapFacet as keymapFacet_alias_1 }
+
+/**
+ * @internal
+ */
+declare type KeymapPayload = Keymap;
+export { KeymapPayload }
+export { KeymapPayload as KeymapPayload_alias_1 }
+
+declare type KeyPressHandler = (view: EditorView, event: KeyboardEvent) => boolean | void;
+export { KeyPressHandler }
+export { KeyPressHandler as KeyPressHandler_alias_1 }
+
+/**
+ * @public
+ */
+declare interface MarkAttrOptions {
+    /**
+     * The name of the mark type.
+     */
+    type: string;
+    /**
+     * The name of the attribute.
+     */
+    attr: string;
+    /**
+     * The default value for this attribute, to use when no explicit value is
+     * provided. Attributes that have no default must be provided whenever a mark
+     * of a type that has them is created.
+     */
+    default?: any;
+    /**
+     * Returns the attribute key and value to be set on the DOM node.
+     */
+    toDOM?: (value: any) => [key: string, value: string] | null | void;
+    /**
+     * Parses the attribute value from the DOM.
+     */
+    parseDOM?: (node: HTMLElement) => any;
+}
+export { MarkAttrOptions }
+export { MarkAttrOptions as MarkAttrOptions_alias_1 }
+
 export declare interface MarkBuilder {
     (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode[];
     (...children: NodeChild[]): ProseMirrorNode[];
@@ -711,6 +1233,47 @@ declare interface MarkSpecOptions<MarkName extends string = string> extends Mark
 export { MarkSpecOptions }
 export { MarkSpecOptions as MarkSpecOptions_alias_1 }
 
+/**
+ * A function that is called when the editor view is mounted.
+ *
+ * @param view - The editor view.
+ *
+ * @public
+ */
+declare type MountHandler = (view: EditorView) => void;
+export { MountHandler }
+export { MountHandler as MountHandler_alias_1 }
+
+/**
+ * @public
+ */
+declare interface NodeAttrOptions {
+    /**
+     * The name of the node type.
+     */
+    type: string;
+    /**
+     * The name of the attribute.
+     */
+    attr: string;
+    /**
+     * The default value for this attribute, to use when no explicit value is
+     * provided. Attributes that have no default must be provided whenever a node
+     * of a type that has them is created.
+     */
+    default?: any;
+    /**
+     * Returns the attribute key and value to be set on the DOM node.
+     */
+    toDOM?: (value: any) => [key: string, value: string] | null | void;
+    /**
+     * Parses the attribute value from the DOM.
+     */
+    parseDOM?: (node: HTMLElement) => any;
+}
+export { NodeAttrOptions }
+export { NodeAttrOptions as NodeAttrOptions_alias_1 }
+
 export declare interface NodeBuilder {
     (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode;
     (...children: NodeChild[]): ProseMirrorNode;
@@ -726,7 +1289,7 @@ export declare type NodeContent = ProseMirrorNode | ProseMirrorFragment | NodeCo
  *
  * @public
  */
-declare function nodeFromElement(element: HTMLElement, schema: Schema): ProseMirrorNode;
+declare function nodeFromElement(element: DOMNode, options: DOMParserOptions & JSONParserOptions): ProseMirrorNode;
 export { nodeFromElement }
 export { nodeFromElement as nodeFromElement_alias_1 }
 
@@ -735,7 +1298,7 @@ export { nodeFromElement as nodeFromElement_alias_1 }
  *
  * @public
  */
-declare function nodeFromHTML(html: string, schema: Schema): ProseMirrorNode;
+declare function nodeFromHTML(html: string, options: DOMParserOptions & JSONParserOptions & DOMDocumentOptions): ProseMirrorNode;
 export { nodeFromHTML }
 export { nodeFromHTML as nodeFromHTML_alias_1 }
 
@@ -744,7 +1307,7 @@ export { nodeFromHTML as nodeFromHTML_alias_1 }
  *
  * @public
  */
-declare function nodeFromJSON(json: NodeJSON, schema: Schema): ProseMirrorNode;
+declare function nodeFromJSON(json: NodeJSON, options: JSONParserOptions): ProseMirrorNode;
 export { nodeFromJSON }
 export { nodeFromJSON as nodeFromJSON_alias_1 }
 
@@ -773,17 +1336,20 @@ declare interface NodeSpecOptions<NodeName extends string = string> extends Node
 export { NodeSpecOptions }
 export { NodeSpecOptions as NodeSpecOptions_alias_1 }
 
-declare type NodeViewEffectOptions = {
+/**
+ * @internal
+ */
+declare type NodeViewFactoryOptions<T> = {
     group: string;
     name: string;
-    args: unknown;
+    args: T;
 } | {
     group: string;
     name?: undefined;
-    factory: (args: unknown) => NodeViewConstructor;
+    factory: (args: T) => NodeViewConstructor;
 };
-export { NodeViewEffectOptions }
-export { NodeViewEffectOptions as NodeViewEffectOptions_alias_1 }
+export { NodeViewFactoryOptions }
+export { NodeViewFactoryOptions as NodeViewFactoryOptions_alias_1 }
 
 declare interface NodeViewOptions {
     name: string;
@@ -792,8 +1358,34 @@ declare interface NodeViewOptions {
 export { NodeViewOptions }
 export { NodeViewOptions as NodeViewOptions_alias_1 }
 
+/**
+ * @internal
+ */
+declare const OBJECT_REPLACEMENT_CHARACTER = "\uFFFC";
+export { OBJECT_REPLACEMENT_CHARACTER }
+export { OBJECT_REPLACEMENT_CHARACTER as OBJECT_REPLACEMENT_CHARACTER_alias_1 }
+
+/**
+ * @internal
+ *
+ * @example
+ *
+ * ```
+ * type MyObject = { a: 1; b: 'B' }
+ * type MyEntries = ObjectEntries<MyObject>
+ * //   ^ ["a", 1] | ["b", "B"]
+ *
+ */
+export declare type ObjectEntries<T extends Record<string, any>> = {
+    [K in keyof T]: [K, T[K]];
+}[keyof T];
+
 export declare function objectEqual<T>(a: T, b: T): boolean;
 
+declare type PasteHandler = (view: EditorView, event: ClipboardEvent, slice: Slice) => boolean | void;
+export { PasteHandler }
+export { PasteHandler as PasteHandler_alias_1 }
+
 declare type Payload = unknown;
 
 export declare type Payloads = PayloadTuple[];
@@ -817,6 +1409,8 @@ export { PluginPayload }
 export { PluginPayload as PluginPayload_alias_1 }
 
 /**
+ * ProseKit extension priority.
+ *
  * @public
  */
 declare const enum Priority {
@@ -831,6 +1425,8 @@ export { Priority as Priority_alias_1 }
 
 /**
  * Base class for all ProseKit errors.
+ *
+ * @internal
  */
 declare class ProseKitError extends Error {
 }
@@ -838,7 +1434,9 @@ export { ProseKitError }
 export { ProseKitError as ProseKitError_alias_1 }
 
 /**
- * Remove the given mark from the inline content.
+ * Returns a command that removes the given mark.
+ *
+ * @public
  */
 declare function removeMark(options: {
     /**
@@ -865,6 +1463,15 @@ export declare const schemaFacet: Facet<SchemaPayload, SchemaPayload>;
 
 export declare type SchemaPayload = SchemaSpec;
 
+declare type ScrollToSelectionHandler = (view: EditorView) => boolean;
+export { ScrollToSelectionHandler }
+export { ScrollToSelectionHandler as ScrollToSelectionHandler_alias_1 }
+
+/**
+ * Returns a command that selects the whole document.
+ *
+ * @public
+ */
 export declare function selectAll(): Command;
 
 /**
@@ -883,6 +1490,8 @@ export { SelectionJSON as SelectionJSON_alias_1 }
 /**
  * Returns a command that tries to set the selected textblocks to the given node
  * type with the given attributes.
+ *
+ * @public
  */
 declare function setBlockType(options: {
     type: NodeType | string;
@@ -893,6 +1502,38 @@ declare function setBlockType(options: {
 export { setBlockType }
 export { setBlockType as setBlockType_alias_1 }
 
+/**
+ * Returns a command that set the attributes of the current node.
+ *
+ * @public
+ */
+declare function setNodeAttrs(options: {
+    /**
+     * The type of node to set the attributes of.
+     *
+     * If current node is not of this type, the command will do nothing.
+     */
+    type: string | NodeType;
+    /**
+     * The attributes to set.
+     */
+    attrs: Attrs;
+    /**
+     * The position of the node. Defaults to the position of the wrapping node
+     * containing the current selection.
+     */
+    pos?: number;
+}): Command;
+export { setNodeAttrs }
+export { setNodeAttrs as setNodeAttrs_alias_1 }
+
+export declare function setSelectionAround(tr: Transaction, pos: number): void;
+
+/**
+ * @internal
+ */
+export declare type Setter<T> = (value: T) => void;
+
 /**
  * @internal
  */
@@ -918,7 +1559,7 @@ export declare const stateFacet: Facet<StatePayload, StatePayload>;
  *
  * @public
  */
-declare function stateFromJSON(json: StateJSON, schema: Schema): EditorState;
+declare function stateFromJSON(json: StateJSON, options: JSONParserOptions): EditorState;
 export { stateFromJSON }
 export { stateFromJSON as stateFromJSON_alias_1 }
 
@@ -944,6 +1585,10 @@ export declare type StatePayload = (ctx: {
     schema: Schema;
 }) => EditorStateConfig;
 
+declare type TextInputHandler = (view: EditorView, from: number, to: number, text: string) => boolean | void;
+export { TextInputHandler }
+export { TextInputHandler as TextInputHandler_alias_1 }
+
 export declare type ToCommandApplier<T extends CommandArgs> = {
     [K in keyof T]: CommandApplier<T[K]>;
 };
@@ -956,6 +1601,11 @@ export declare type ToCommandCreators<T extends CommandArgs> = {
     [K in keyof T]: CommandCreator<T[K]>;
 };
 
+/**
+ * Returns a command that toggles the given mark with the given attributes.
+ *
+ * @public
+ */
 declare function toggleMark({ type, attrs, }: {
     type: string | MarkType;
     attrs?: Attrs | null;
@@ -963,6 +1613,12 @@ declare function toggleMark({ type, attrs, }: {
 export { toggleMark }
 export { toggleMark as toggleMark_alias_1 }
 
+/**
+ * Returns a command that set the selected textblocks to the given node type
+ * with the given attributes.
+ *
+ * @public
+ */
 declare function toggleNode({ type, attrs, }: {
     type: string | NodeType;
     attrs?: Attrs | null;
@@ -970,8 +1626,21 @@ declare function toggleNode({ type, attrs, }: {
 export { toggleNode }
 export { toggleNode as toggleNode_alias_1 }
 
+declare type TripleClickHandler = (view: EditorView, pos: number, event: MouseEvent) => boolean | void;
+export { TripleClickHandler }
+export { TripleClickHandler as TripleClickHandler_alias_1 }
+
+declare type TripleClickOnHandler = (view: EditorView, pos: number, node: Node_3, nodePos: number, event: MouseEvent, direct: boolean) => boolean | void;
+export { TripleClickOnHandler }
+export { TripleClickOnHandler as TripleClickOnHandler_alias_1 }
+
 declare type Tuple5<T> = [T, T, T, T, T];
 
+/**
+ * Merge multiple extensions into one.
+ *
+ * @public
+ */
 declare function union<E extends Extension | Extension[]>(extension: E): SimplifyExtension<E>;
 export { union }
 export { union as union_alias_1 }
@@ -989,6 +1658,15 @@ export declare function uniqPush<T>(prev: readonly T[], next: readonly T[]): T[]
 
 export declare function uniqRemove<T>(prev: T[], next: T[]): T[];
 
+/**
+ * A function that is called when the editor view is unmounted.
+ *
+ * @public
+ */
+declare type UnmountHandler = () => void;
+export { UnmountHandler }
+export { UnmountHandler as UnmountHandler_alias_1 }
+
 export declare function updateExtension(prevInputs: Payloads, prevConverters: Converters, extension: Extension, mode: 'add' | 'remove'): {
     schemaInput: SchemaPayload | null;
     stateInput: StatePayload | null;
@@ -996,10 +1674,17 @@ export declare function updateExtension(prevInputs: Payloads, prevConverters: Co
     commandInput: CommandCreators | null;
 };
 
-export declare type UpdateHandler = (options: {
-    view: EditorView;
-    prevState?: EditorState;
-}) => void;
+/**
+ * A function that is called when the editor state is updated.
+ *
+ * @param view - The editor view.
+ * @param prevState - The previous editor state.
+ *
+ * @public
+ */
+declare type UpdateHandler = (view: EditorView, prevState: EditorState) => void;
+export { UpdateHandler }
+export { UpdateHandler as UpdateHandler_alias_1 }
 
 export declare const viewFacet: Facet<ViewPayload, ViewPayload>;
 
@@ -1014,6 +1699,19 @@ declare function withPriority<T extends Extension>(extension: T, priority: Prior
 export { withPriority }
 export { withPriority as withPriority_alias_1 }
 
+/**
+ * @internal
+ */
+declare function withSkipCodeBlock(command: Command): Command;
+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.
+ *
+ * @public
+ */
 export declare function wrap({ nodeType, attrs, }: {
     nodeType: NodeType;
     attrs?: Attrs | null;