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

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

@@ -0,0 +1,1720 @@
+import { AllSelection } from '@prosekit/pm/state';
+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 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';
+import { ProseMirrorFragment } from '@prosekit/pm/model';
+import { ProseMirrorNode } from '@prosekit/pm/model';
+import { Schema } from '@prosekit/pm/model';
+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';
+
+declare type Action = (options: {
+    tr: Transaction;
+    view?: EditorView;
+}) => boolean;
+
+/**
+ * Returns a command that adds the given mark with the given attributes.
+ *
+ * @public
+ */
+declare function addMark(options: {
+    /**
+     * The type of the mark to add.
+     */
+    type: string | MarkType;
+    /**
+     * The attributes of the mark to add.
+     */
+    attrs?: Attrs | null;
+    /**
+     * The start position of the document. By default it will be the start position of current selection.
+     */
+    from?: number;
+    /**
+     * The end position of the document. By default it will be the end position of current selection.
+     */
+    to?: number;
+}): Command;
+export { addMark }
+export { addMark as addMark_alias_1 }
+
+export declare function applyAction(operator: Action): Command;
+
+/**
+ * Utility function assert that two types are equal in tests.
+ */
+export declare function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void;
+
+export declare function attrsMatch(nodeOrMark: ProseMirrorNode | Mark, attrs: Attrs): boolean;
+
+export declare abstract class BaseExtension<T extends ExtensionTyping = ExtensionTyping> implements Extension<T> {
+    extension: Extension | Extension[];
+    priority?: Priority;
+    _type?: T;
+    /**
+     * @internal
+     *
+     * Whether this extension has payload that can be converted to a schema.
+     *
+     * Notice that this does not mean that the extension has a schema. For
+     * example, a `FacetExtension` with a `schemaFacet` will return `true` for
+     * this property, but will return `null` for `schema`.
+     */
+    abstract hasSchema: boolean;
+    /**
+     * @internal
+     *
+     * The schema that this extension represents.
+     */
+    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;
+}
+
+/**
+ * @internal
+ */
+declare interface CommandArgs {
+    [name: string]: any[];
+}
+export { CommandArgs }
+export { CommandArgs as CommandArgs_alias_1 }
+
+export declare type CommandCreator<Args extends any[] = any[]> = (...arg: Args) => Command;
+
+export declare interface CommandCreators {
+    [name: string]: CommandCreator;
+}
+
+export declare const commandFacet: Facet<CommandCreators, CommandCreators>;
+
+export declare type CommandPayload = CommandCreators;
+
+export declare type Converters = ConverterTuple[];
+
+declare type ConverterTuple = Tuple5<FacetConverter | undefined>;
+
+/**
+ * @public
+ */
+declare function createEditor<E extends Extension>(options: EditorOptions<E>): Editor<E>;
+export { createEditor }
+export { createEditor as createEditor_alias_1 }
+
+export declare function createMarkBuilder(getState: () => EditorState | null | undefined, type: MarkType): MarkBuilder;
+
+export declare function createNodeBuilder(getState: () => EditorState | null | undefined, type: NodeType): NodeBuilder;
+
+export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
+
+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 {
+    /**
+     * A JSON object representing the starting document to use when creating the
+     * editor.
+     */
+    defaultDoc?: NodeJSON;
+    /**
+     * A HTML element or a HTML string representing the starting document to use
+     * when creating the editor.
+     */
+    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.
+     */
+    defaultSelection?: SelectionJSON;
+}
+export { DefaultStateOptions }
+export { DefaultStateOptions as DefaultStateOptions_alias_1 }
+
+/**
+ * Add some base commands
+ *
+ * @public
+ */
+declare function defineBaseCommands(): Extension<{
+    COMMAND_ARGS: {
+        insertText: [{
+            text: string;
+            from?: number | undefined;
+            to?: number | undefined;
+        }];
+        insertNode: [options: {
+            node: Node_2;
+            pos?: number | undefined;
+            type?: undefined;
+            attrs?: undefined;
+        } | {
+            node?: undefined;
+            pos?: number | undefined;
+            type: string;
+            attrs?: Attrs_2 | undefined;
+        }];
+        wrap: [{
+            nodeType: NodeType_2;
+            attrs?: Attrs_2 | null | undefined;
+        }];
+        setBlockType: [options: {
+            type: string | NodeType_2;
+            attrs?: Attrs_2 | null | undefined;
+            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;
+            attrs?: Attrs_2 | null | undefined;
+            from?: number | undefined;
+            to?: number | undefined;
+        }];
+        removeMark: [options: {
+            type: string | MarkType_2;
+            attrs?: Attrs_2 | null | undefined;
+            from?: number | undefined;
+            to?: number | undefined;
+        }];
+    };
+}>;
+export { defineBaseCommands }
+export { defineBaseCommands as defineBaseCommands_alias_1 }
+
+/**
+ * Defines some basic key bindings.
+ *
+ * @public
+ */
+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]>;
+    };
+}>;
+export { defineCommands }
+export { defineCommands as defineCommands_alias_1 }
+
+declare function defineDefaultState({ defaultDoc, defaultHTML, defaultSelection, }: DefaultStateOptions): Extension;
+export { defineDefaultState }
+export { defineDefaultState as defineDefaultState_alias_1 }
+
+/**
+ * @public
+ */
+declare function defineDoc(): Extension<    {
+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.
+ */
+declare function defineHistory(): Extension<    {
+COMMAND_ARGS: {
+undo: [];
+redo: [];
+};
+}>;
+export { defineHistory }
+export { defineHistory as defineHistory_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleKeyDown}
+ */
+declare function defineKeyDownHandler(handler: KeyDownHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineKeyDownHandler }
+export { defineKeyDownHandler as defineKeyDownHandler_alias_1 }
+
+/**
+ * @public
+ */
+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
+ */
+declare function defineMarkSpec<Mark extends string>(options: MarkSpecOptions<Mark>): Extension<{
+    MARKS: Mark;
+}>;
+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<{
+    NODES: NodeName;
+}>;
+export { defineNodeSpec }
+export { defineNodeSpec as defineNodeSpec_alias_1 }
+
+declare function defineNodeView(options: NodeViewOptions): Extension;
+export { defineNodeView }
+export { defineNodeView as defineNodeView_alias_1 }
+
+/**
+ * @internal
+ */
+declare function defineNodeViewFactory<T>(options: NodeViewFactoryOptions<T>): Extension;
+export { defineNodeViewFactory }
+export { defineNodeViewFactory as defineNodeViewFactory_alias_1 }
+
+/**
+ * @public
+ *
+ * Defines a paragraph node spec as the highest priority, because it should be the default block node for most cases.
+ */
+declare function defineParagraph(): Extension<    {
+NODES: "paragraph";
+}>;
+export { defineParagraph }
+export { defineParagraph as defineParagraph_alias_1 }
+
+/**
+ * @public
+ *
+ * Defines a paragraph node spec.
+ */
+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.
+ *
+ * @param plugin - The ProseMirror plugin to add, or an array of plugins, or a
+ * function that returns one or multiple plugins.
+ *
+ * @public
+ */
+declare function definePlugin(plugin: Plugin_2 | Plugin_2[] | ((context: {
+    schema: Schema;
+}) => Plugin_2 | Plugin_2[])): Extension;
+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
+ */
+declare function defineText(): Extension<    {
+NODES: "text";
+}>;
+export { defineText }
+export { defineText as defineText_alias_1 }
+
+/**
+ * @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
+ */
+declare class Editor<E extends Extension = any> {
+    private instance;
+    private constructor();
+    private afterMounted;
+    /**
+     * @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>;
+    /**
+     * 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;
+    /**
+     * Focus the editor.
+     */
+    focus(): void;
+    /**
+     * Blur the editor.
+     */
+    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
+ */
+declare interface EditorOptions<E extends Extension> {
+    /**
+     * The extension to use when creating the editor.
+     */
+    extension: E;
+    /**
+     * A JSON object representing the starting document to use when creating the
+     * editor.
+     */
+    defaultDoc?: NodeJSON;
+    /**
+     * A HTML element or a HTML string representing the starting document to use
+     * when creating the editor.
+     */
+    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.
+     */
+    defaultSelection?: SelectionJSON;
+}
+export { EditorOptions }
+export { EditorOptions as EditorOptions_alias_1 }
+
+/**
+ * Parse a HTML string to a HTML element.
+ *
+ * @internal
+ */
+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
+ */
+declare interface Extension<T extends ExtensionTyping = ExtensionTyping> {
+    extension: Extension | Extension[];
+    priority?: Priority;
+    _type?: T;
+    /**
+     * @public
+     *
+     * The schema that this extension represents.
+     */
+    schema: Schema | null;
+}
+export { Extension }
+export { Extension as Extension_alias_1 }
+
+/**
+ * @internal
+ */
+declare interface ExtensionTyping<Node extends string = string, Mark extends string = string, Commands extends CommandArgs = CommandArgs> {
+    NODES?: Node;
+    MARKS?: Mark;
+    COMMAND_ARGS?: Commands;
+}
+export { ExtensionTyping }
+export { ExtensionTyping as ExtensionTyping_alias_1 }
+
+/**
+ * @public
+ */
+declare type ExtractCommandAppliers<E extends Extension> = ToCommandApplier<ExtractCommandArgs<E>>;
+export { ExtractCommandAppliers }
+export { ExtractCommandAppliers as ExtractCommandAppliers_alias_1 }
+
+/**
+ * @internal
+ */
+export declare type ExtractCommandArgs<E extends Extension> = ExtractCommandArgsFromTyping<ExtractTyping<E>>;
+
+export declare type ExtractCommandArgsFromTyping<T extends ExtensionTyping> = ExtractKey<T, 'COMMAND_ARGS'>;
+
+/**
+ * @public
+ */
+declare type ExtractCommandCreators<E extends Extension> = ToCommandCreators<ExtractCommandArgs<E>>;
+export { ExtractCommandCreators }
+export { ExtractCommandCreators as ExtractCommandCreators_alias_1 }
+
+/**
+ * @intneral
+ */
+export declare type ExtractKey<T, K extends string> = Extract<T, Record<K, any>>[K];
+
+/**
+ * @public
+ */
+declare type ExtractMarks<E extends Extension> = ExtractMarksFromTyping<ExtractTyping<E>>;
+export { ExtractMarks }
+export { ExtractMarks as ExtractMarks_alias_1 }
+
+export declare type ExtractMarksFromTyping<T extends ExtensionTyping> = ExtractKey<T, 'MARKS'>;
+
+/**
+ * @public
+ */
+declare type ExtractNodes<E extends Extension> = ExtractNodesFromTyping<ExtractTyping<E>>;
+export { ExtractNodes }
+export { ExtractNodes as ExtractNodes_alias_1 }
+
+export declare type ExtractNodesFromTyping<T extends ExtensionTyping> = ExtractKey<T, 'NODES'>;
+
+/**
+ * @internal
+ */
+export declare type ExtractTyping<E extends Extension> = E extends Extension<infer T> ? T : never;
+
+/**
+ * @public
+ */
+declare class Facet<Input, Output> {
+    /**
+     * @internal
+     */
+    readonly index: number;
+    /**
+     * @internal
+     */
+    readonly converter: () => FacetConverter<Input, Output>;
+    /**
+     * @internal
+     */
+    readonly next: Facet<Output, any> | null;
+    /**
+     * @internal
+     */
+    readonly singleton: boolean;
+    /**
+     * @internal
+     */
+    isSchema: boolean;
+    private constructor();
+    static define<Input, Output>({ converter, convert, next, singleton, }: FacetOptions<Input, Output>): Facet<Input, Output>;
+    /**
+     * @internal
+     */
+    static defineRootFacet<Input>(options: Omit<FacetOptions<Input, Input>, 'next'>): Facet<Input, Input>;
+    extension(payloads: Input[]): Extension;
+}
+export { Facet }
+export { Facet as Facet_alias_1 }
+
+/**
+ * @public
+ */
+export declare interface FacetConverter<Input = any, Output = any> {
+    create: (inputs: Input[]) => Output;
+    update: (inputs: Input[]) => Output | null;
+}
+
+/**
+ * @public
+ */
+export declare class FacetExtensionImpl<Input, Output> extends BaseExtension {
+    readonly facet: Facet<Input, Output>;
+    readonly payloads: Input[];
+    extension: Extension;
+    hasSchema: boolean;
+    schema: null;
+    constructor(facet: Facet<Input, Output>, payloads: Input[]);
+}
+
+/**
+ * @public
+ */
+declare interface FacetOptions<Input, Output> {
+    convert?: (payloads: Input[]) => Output;
+    converter?: () => FacetConverter<Input, Output>;
+    next: Facet<Output, any>;
+    singleton?: boolean;
+}
+export { FacetOptions }
+export { FacetOptions as FacetOptions_alias_1 }
+
+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(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
+ */
+declare function getMarkType(schema: Schema, type: string | MarkType): MarkType;
+export { getMarkType }
+export { getMarkType as getMarkType_alias_1 }
+
+/**
+ * @internal
+ */
+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;
+    type?: undefined;
+    attrs?: undefined;
+} | {
+    node?: undefined;
+    pos?: number;
+    type: string;
+    attrs?: Attrs;
+}): Command;
+export { insertNode }
+export { insertNode as insertNode_alias_1 }
+
+export declare function insertNodeAction({ node, pos, }: {
+    node: ProseMirrorNode;
+    pos?: number;
+}): Action;
+
+/**
+ * Returns a command that inserts the given text.
+ *
+ * @public
+ */
+export declare function insertText({ text, from, to, }: {
+    text: string;
+    from?: number;
+    to?: number;
+}): Command;
+
+/**
+ * @internal
+ */
+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;
+
+/**
+ * @internal
+ */
+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;
+
+/**
+ * @internal
+ */
+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
+ */
+declare function isProseMirrorNode(node: unknown): node is ProseMirrorNode;
+export { isProseMirrorNode }
+export { isProseMirrorNode as isProseMirrorNode_alias_1 }
+
+/**
+ * @internal
+ */
+declare function isTextSelection(sel: Selection_2): sel is TextSelection;
+export { isTextSelection }
+export { isTextSelection as isTextSelection_alias_1 }
+
+/**
+ * Serialize a HTML element to a ProseMirror document JSON object.
+ *
+ * @public
+ */
+export declare function jsonFromElement(element: DOMNode, options: DOMParserOptions & JSONParserOptions): NodeJSON;
+
+/**
+ * Parse a HTML string to a ProseMirror document JSON object.
+ *
+ * @public
+ */
+declare function jsonFromHTML(html: string, options: DOMDocumentOptions & DOMParserOptions & JSONParserOptions): NodeJSON;
+export { jsonFromHTML }
+export { jsonFromHTML as jsonFromHTML_alias_1 }
+
+/**
+ * Return a JSON object representing this node.
+ *
+ * @public
+ */
+declare function jsonFromNode(node: ProseMirrorNode): NodeJSON;
+export { jsonFromNode }
+export { jsonFromNode as jsonFromNode_alias_1 }
+
+/**
+ * Return a JSON object representing this state.
+ *
+ * @public
+ */
+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
+ */
+declare interface Keymap {
+    [key: string]: Command;
+}
+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[];
+    isActive(attrs?: Attrs): boolean;
+}
+
+/**
+ * @public
+ */
+declare interface MarkSpecOptions<MarkName extends string = string> extends MarkSpec {
+    name: MarkName;
+}
+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;
+    isActive(attrs?: Attrs): boolean;
+}
+
+export declare type NodeChild = ProseMirrorNode | string | NodeChild[];
+
+export declare type NodeContent = ProseMirrorNode | ProseMirrorFragment | NodeContent[];
+
+/**
+ * Parse a HTML element to a ProseMirror node.
+ *
+ * @public
+ */
+declare function nodeFromElement(element: DOMNode, options: DOMParserOptions & JSONParserOptions): ProseMirrorNode;
+export { nodeFromElement }
+export { nodeFromElement as nodeFromElement_alias_1 }
+
+/**
+ * Parse a HTML string to a ProseMirror node.
+ *
+ * @public
+ */
+declare function nodeFromHTML(html: string, options: DOMParserOptions & JSONParserOptions & DOMDocumentOptions): ProseMirrorNode;
+export { nodeFromHTML }
+export { nodeFromHTML as nodeFromHTML_alias_1 }
+
+/**
+ * Parse a JSON object to a ProseMirror node.
+ *
+ * @public
+ */
+declare function nodeFromJSON(json: NodeJSON, options: JSONParserOptions): ProseMirrorNode;
+export { nodeFromJSON }
+export { nodeFromJSON as nodeFromJSON_alias_1 }
+
+/**
+ * A JSON representation of the prosemirror node.
+ *
+ * @public
+ */
+declare interface NodeJSON {
+    type: string;
+    marks?: Array<any>;
+    text?: string;
+    content?: NodeJSON[];
+    attrs?: Record<string, any>;
+}
+export { NodeJSON }
+export { NodeJSON as NodeJSON_alias_1 }
+
+/**
+ * @public
+ */
+declare interface NodeSpecOptions<NodeName extends string = string> extends NodeSpec {
+    name: NodeName;
+    topNode?: boolean;
+}
+export { NodeSpecOptions }
+export { NodeSpecOptions as NodeSpecOptions_alias_1 }
+
+/**
+ * @internal
+ */
+declare type NodeViewFactoryOptions<T> = {
+    group: string;
+    name: string;
+    args: T;
+} | {
+    group: string;
+    name?: undefined;
+    factory: (args: T) => NodeViewConstructor;
+};
+export { NodeViewFactoryOptions }
+export { NodeViewFactoryOptions as NodeViewFactoryOptions_alias_1 }
+
+declare interface NodeViewOptions {
+    name: string;
+    constructor: NodeViewConstructor;
+}
+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[];
+
+declare type PayloadTuple = Tuple5<Payload[]>;
+
+/**
+ * @internal
+ */
+declare const pluginFacet: Facet<PluginPayload, StatePayload>;
+export { pluginFacet }
+export { pluginFacet as pluginFacet_alias_1 }
+
+/**
+ * @internal
+ */
+declare type PluginPayload = (context: {
+    schema: Schema;
+}) => Plugin_2 | Plugin_2[];
+export { PluginPayload }
+export { PluginPayload as PluginPayload_alias_1 }
+
+/**
+ * ProseKit extension priority.
+ *
+ * @public
+ */
+declare const enum Priority {
+    lowest = 4,
+    low = 3,
+    default = 2,
+    high = 1,
+    highest = 0
+}
+export { Priority }
+export { Priority as Priority_alias_1 }
+
+/**
+ * Base class for all ProseKit errors.
+ *
+ * @internal
+ */
+declare class ProseKitError extends Error {
+}
+export { ProseKitError }
+export { ProseKitError as ProseKitError_alias_1 }
+
+/**
+ * Returns a command that removes the given mark.
+ *
+ * @public
+ */
+declare function removeMark(options: {
+    /**
+     * The type of the mark to remove.
+     */
+    type: string | MarkType;
+    /**
+     * If attrs is given, remove precisely the mark with the given attrs. Otherwise, remove all marks of the given type.
+     */
+    attrs?: Attrs | null;
+    /**
+     * The start position of the document. By default it will be the start position of current selection.
+     */
+    from?: number;
+    /**
+     * The end position of the document. By default it will be the end position of current selection.
+     */
+    to?: number;
+}): Command;
+export { removeMark }
+export { removeMark as removeMark_alias_1 }
+
+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;
+
+/**
+ * A JSON representation of the prosemirror selection.
+ *
+ * @public
+ */
+declare interface SelectionJSON {
+    anchor: number;
+    head: number;
+    type: string;
+}
+export { SelectionJSON }
+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;
+    attrs?: Attrs | null;
+    from?: number;
+    to?: number;
+}): Command;
+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
+ */
+declare type SimplifyExtension<E extends Extension | Extension[]> = E extends Extension[] ? Extension<ExceptEmptyValue<{
+    NODES: ExtractNodes<E[number]>;
+    MARKS: ExtractMarks<E[number]>;
+    COMMAND_ARGS: SimplifyUnion<ExtractCommandArgs<E[number]>>;
+}>> : E;
+export { SimplifyExtension }
+export { SimplifyExtension as SimplifyExtension_alias_1 }
+
+/**
+ * @intneral
+ */
+declare type SimplifyUnion<T> = Simplify<UnionToIntersection<T>>;
+export { SimplifyUnion }
+export { SimplifyUnion as SimplifyUnion_alias_1 }
+
+export declare const stateFacet: Facet<StatePayload, StatePayload>;
+
+/**
+ * Parse a JSON object to a ProseMirror state.
+ *
+ * @public
+ */
+declare function stateFromJSON(json: StateJSON, options: JSONParserOptions): EditorState;
+export { stateFromJSON }
+export { stateFromJSON as stateFromJSON_alias_1 }
+
+/**
+ * A JSON representation of the prosemirror state.
+ *
+ * @public
+ */
+declare interface StateJSON {
+    /**
+     * The main `ProseMirror` doc.
+     */
+    doc: NodeJSON;
+    /**
+     * The current selection.
+     */
+    selection: SelectionJSON;
+}
+export { StateJSON }
+export { StateJSON as StateJSON_alias_1 }
+
+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]>;
+};
+
+export declare type ToCommandArgs<T extends CommandCreators> = {
+    [K in keyof T]: Parameters<T[K]>;
+};
+
+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;
+}): Command;
+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;
+}): Command;
+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 }
+
+export declare class UnionExtensionImpl<T extends ExtensionTyping = ExtensionTyping> extends BaseExtension<T> implements Extension<T> {
+    extension: BaseExtension[];
+    private _schema;
+    private hasSchemaCount;
+    constructor(extension?: BaseExtension[]);
+    get hasSchema(): boolean;
+    get schema(): Schema | null;
+}
+
+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;
+    viewInput: ViewPayload | null;
+    commandInput: CommandCreators | null;
+};
+
+/**
+ * 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>;
+
+export declare type ViewPayload = Omit<DirectEditorProps, 'state'>;
+
+export declare function voidFunction(): void;
+
+/**
+ * @public
+ */
+declare function withPriority<T extends Extension>(extension: T, priority: Priority): T;
+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;
+}): Command;
+
+export { }