@prosekit/core 0.8.0 → 0.8.1

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

@@ -1,3063 +0,0 @@
-import { AllSelection } from '@prosekit/pm/state';
-import type { Attrs } from '@prosekit/pm/model';
-import { Command } from '@prosekit/pm/state';
-import type { ContentMatch } from '@prosekit/pm/model';
-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 type { MarkType } from '@prosekit/pm/model';
-import type { MarkViewConstructor } from '@prosekit/pm/view';
-import type { Node as Node_2 } from '@prosekit/pm/model';
-import { NodeSelection } from '@prosekit/pm/state';
-import type { NodeSpec } from '@prosekit/pm/model';
-import type { NodeType } from '@prosekit/pm/model';
-import type { NodeView } from '@prosekit/pm/view';
-import type { NodeViewConstructor } from '@prosekit/pm/view';
-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';
-import type { ResolvedPos } from '@prosekit/pm/model';
-import { Schema } from '@prosekit/pm/model';
-import { SchemaSpec } from '@prosekit/pm/model';
-import { Selection as Selection_2 } from '@prosekit/pm/state';
-import type { Simplify } from 'type-fest';
-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';
-
-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: AddMarkOptions): Command;
-export { addMark }
-export { addMark as addMark_alias_1 }
-
-/**
- * @public
- */
-declare interface AddMarkOptions {
-    /**
-     * 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;
-}
-export { AddMarkOptions }
-export { AddMarkOptions as AddMarkOptions_alias_1 }
-
-/**
- * An object holding the attributes of a node.
-
- * @public
- */
-declare type AnyAttrs = Attrs;
-export { AnyAttrs }
-export { AnyAttrs as AnyAttrs_alias_1 }
-
-/**
- * @internal
- */
-declare type AnyFunction = (...args: any[]) => any;
-export { AnyFunction }
-export { AnyFunction as AnyFunction_alias_1 }
-
-export declare function applyAction(operator: Action): Command;
-
-export declare const applyMarkForTest: ApplyMarkFunction;
-
-/**
- * @internal
- */
-export declare type ApplyMarkFunction = (mark: Mark, children: ProseMirrorNode[]) => ProseMirrorNode[];
-
-/**
- * @internal
- */
-export declare function arrayRemove<T>(array: T[], item: T): void;
-
-/**
- * @internal
- */
-export declare function arraySubstract<T>(a: T[], b: T[]): T[];
-
-/**
- * @internal
- */
-declare function assert(condition: unknown, message?: string): asserts condition;
-export { assert }
-export { assert as assert_alias_1 }
-
-/**
- * Utility function assert that two types are equal in tests.
- */
-export declare function assertTypeEqual<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;
-
-/**
- * @public
- */
-declare type AttrSpec<AttrType = any> = {
-    /**
-     * 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
-     * or mark of a type that has them is created.
-     */
-    default?: AttrType;
-    /**
-     * A function or type name used to validate values of this attribute. This
-     * will be used when deserializing the attribute from JSON, and when running
-     * [`Node.check`](https://prosemirror.net/docs/ref/#model.Node.check). When a
-     * function, it should raise an exception if the value isn't of the expected
-     * type or shape. When a string, it should be a `|`-separated string of
-     * primitive types (`"number"`, `"string"`, `"boolean"`, `"null"`, and
-     * `"undefined"`), and the library will raise an error when the value is not
-     * one of those types.
-     */
-    validate?: string | ((value: unknown) => void);
-};
-export { AttrSpec }
-export { AttrSpec as AttrSpec_alias_1 }
-
-/**
- * @internal
- */
-declare type BaseCommandsExtension = Extension<{
-    Commands: {
-        insertText: [options: InsertTextOptions];
-        insertNode: [options: InsertNodeOptions];
-        removeNode: [options: RemoveNodeOptions];
-        wrap: [options: WrapOptions];
-        toggleWrap: [options: ToggleWrapOptions];
-        setBlockType: [options: SetBlockTypeOptions];
-        setNodeAttrs: [options: SetNodeAttrsOptions];
-        insertDefaultBlock: [options?: InsertDefaultBlockOptions];
-        selectAll: [];
-        addMark: [options: AddMarkOptions];
-        removeMark: [options: RemoveMarkOptions];
-        unsetBlockType: [options?: UnsetBlockTypeOptions];
-        unsetMark: [options?: UnsetMarkOptions];
-    };
-}>;
-export { BaseCommandsExtension }
-export { BaseCommandsExtension as BaseCommandsExtension_alias_1 }
-
-/**
- * @internal
- */
-export declare abstract class BaseExtension<T extends ExtensionTyping = ExtensionTyping> implements Extension<T> {
-    abstract extension: Extension | Extension[];
-    priority?: Priority;
-    _type?: T;
-    private trees;
-    /**
-     * @internal
-     */
-    abstract createTree(priority: Priority): FacetNode;
-    /**
-     * @internal
-     */
-    getTree(priority?: Priority): FacetNode;
-    /**
-     * @internal
-     */
-    findFacetOutput<I, O>(facet: Facet<I, O>): Tuple5<O | null> | null;
-    get schema(): Schema | null;
-}
-
-/**
- * @internal
- */
-declare type BaseKeymapExtension = PlainExtension;
-export { BaseKeymapExtension }
-export { BaseKeymapExtension as BaseKeymapExtension_alias_1 }
-
-/**
- * Some basic props for custom node views.
- *
- * @deprecated - This is no longer needed. Use `CoreNodeViewUserOptions` from `@prosemirror-adapter/core` instead.
- *
- * @hidden
- */
-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 }
-
-export declare function buildNode(type: NodeType, args: [Attrs | NodeChild | null | undefined, ...NodeChild[]], createNode: CreateNodeFunction): ProseMirrorNode;
-
-export declare function cache<T>(fn: () => T): () => T;
-
-declare const canUseRegexLookbehind: () => boolean;
-export { canUseRegexLookbehind }
-export { canUseRegexLookbehind as canUseRegexLookbehind_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_2, nodePos: number, event: MouseEvent, direct: boolean) => boolean | void;
-export { ClickOnHandler }
-export { ClickOnHandler as ClickOnHandler_alias_1 }
-
-/**
- * @internal
- */
-declare interface ClipboardSerializerOptions {
-    serializeFragmentWrapper?: FunctionWrapper<SerializeFragmentFunction>;
-    serializeNodeWrapper?: FunctionWrapper<SerializeNodeFunction>;
-    nodesFromSchemaWrapper?: FunctionWrapper<NodesFromSchemaFunction>;
-    marksFromSchemaWrapper?: FunctionWrapper<MarksFromSchemaFunction>;
-}
-export { ClipboardSerializerOptions }
-export { ClipboardSerializerOptions as ClipboardSerializerOptions_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 }
-
-/**
- * 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>>(): [
-setHandlers: (eventHandlers: Handler[]) => void,
-combinedEventHandler: (...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 `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 }
-export { CommandAction as CommandAction_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<CommandPayload, RootPayload>;
-
-export declare type CommandPayload = CommandCreators;
-
-/**
- * @internal
- */
-declare interface CommandTyping {
-    [name: string]: any[];
-}
-export { CommandTyping }
-export { CommandTyping as CommandTyping_alias_1 }
-
-/**
- * @internal
- */
-declare function containsInlineNode(doc: ProseMirrorNode, from: number, to: number): boolean;
-export { containsInlineNode }
-export { containsInlineNode as containsInlineNode_alias_1 }
-
-/**
- * @public
- */
-declare function createEditor<E extends Extension>(options: EditorOptions<E>): Editor<E>;
-export { createEditor }
-export { createEditor as createEditor_alias_1 }
-
-/**
- * @internal
- */
-export declare function createMarkActions(schema: Schema, getState: GetStateFunction, applyMark?: ApplyMarkFunction): Record<string, MarkAction>;
-
-/**
- * @internal
- */
-export declare function createNodeActions(schema: Schema, getState: GetStateFunction, createNode?: CreateNodeFunction): Record<string, NodeAction>;
-
-export declare const createNodeForTest: CreateNodeFunction;
-
-/**
- * @internal
- */
-export declare type CreateNodeFunction = (type: NodeType, attrs: Attrs | null, children: ProseMirrorNode[]) => ProseMirrorNode;
-
-/**
- * @public
- */
-declare function createTestEditor<E extends Extension>(options: EditorOptions<E>): TestEditor<E>;
-export { createTestEditor }
-export { createTestEditor as createTestEditor_alias_1 }
-
-export declare function deepEquals<T>(a: T, b: T): boolean;
-
-/**
- * @internal
- */
-declare function defaultBlockAt(match: ContentMatch): NodeType | 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 `defaultContent` is also provided.
-     */
-    defaultSelection?: SelectionJSON;
-}
-export { DefaultStateOptions }
-export { DefaultStateOptions as DefaultStateOptions_alias_1 }
-
-/**
- * Add some base commands
- *
- * @public
- */
-declare function defineBaseCommands(): BaseCommandsExtension;
-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;
-}): BaseKeymapExtension;
-export { defineBaseKeymap }
-export { defineBaseKeymap as defineBaseKeymap_alias_1 }
-
-/**
- * @public
- *
- * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleClick}
- */
-declare function defineClickHandler(handler: ClickHandler): PlainExtension;
-export { defineClickHandler }
-export { defineClickHandler as defineClickHandler_alias_1 }
-
-/**
- * @public
- *
- * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleClickOn}
- */
-declare function defineClickOnHandler(handler: ClickOnHandler): PlainExtension;
-export { defineClickOnHandler }
-export { defineClickOnHandler as defineClickOnHandler_alias_1 }
-
-/**
- * @internal
- */
-declare function defineClipboardSerializer(options: ClipboardSerializerOptions): Extension;
-export { defineClipboardSerializer }
-export { defineClipboardSerializer as defineClipboardSerializer_alias_1 }
-
-declare function defineCommands<T extends Record<string, CommandCreator> = Record<string, CommandCreator>>(commands: T): Extension<{
-    Commands: {
-        [K in keyof T]: Parameters<T[K]>;
-    };
-}>;
-export { defineCommands }
-export { defineCommands as defineCommands_alias_1 }
-
-/**
- * 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 }
-
-/**
- * @public
- *
- * @deprecated Use the following import instead:
- *
- * ```ts
- * import { defineDoc } from 'prosekit/extensions/doc'
- * ```
- */
-declare function defineDoc(): DocExtension;
-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): PlainExtension;
-export { defineDocChangeHandler }
-export { defineDocChangeHandler as defineDocChangeHandler_alias_1 }
-
-/**
- * @internal
- */
-export declare function defineDomEventFacetPayload(...payloads: DOMEventPayload[]): PlainExtension;
-
-/**
- * Register a new event handler for the given event type.
- *
- * @public
- */
-declare function defineDOMEventHandler<Event extends keyof DOMEventMap = string>(event: Event, handler: DOMEventHandler<Event>): PlainExtension;
-export { defineDOMEventHandler }
-export { defineDOMEventHandler as defineDOMEventHandler_alias_1 }
-
-/**
- * @public
- *
- * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleDoubleClick}
- */
-declare function defineDoubleClickHandler(handler: DoubleClickHandler): PlainExtension;
-export { defineDoubleClickHandler }
-export { defineDoubleClickHandler as defineDoubleClickHandler_alias_1 }
-
-/**
- * @public
- *
- * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleDoubleClickOn}
- */
-declare function defineDoubleClickOnHandler(handler: DoubleClickOnHandler): PlainExtension;
-export { defineDoubleClickOnHandler }
-export { defineDoubleClickOnHandler as defineDoubleClickOnHandler_alias_1 }
-
-/**
- * @public
- *
- * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleDrop}
- */
-declare function defineDropHandler(handler: DropHandler): PlainExtension;
-export { defineDropHandler }
-export { defineDropHandler as defineDropHandler_alias_1 }
-
-/**
- * @internal
- */
-declare function defineFacet<Input, Output>(options: {
-    /**
-     * The parent facet in the tree.
-     */
-    parent: Facet<Output, any>;
-    /**
-     * Set this to true if you only want to keep one facet payload. For example,
-     * this facet corresponds to a ProseMirror plugin with a key.
-     */
-    singleton?: boolean;
-    /**
-     * A reducer is a function that accepts an array of input and produce a single
-     * output.
-     */
-    reducer?: FacetReducer<Input, Output>;
-    /**
-     * A callback function that returns a reducer. This is useful if you want to
-     * store something in the closure.
-     */
-    reduce?: () => FacetReducer<Input, Output>;
-}): Facet<Input, Output>;
-export { defineFacet }
-export { defineFacet as defineFacet_alias_1 }
-
-/**
- * @internal
- */
-declare function defineFacetPayload<Input>(facet: Facet<Input, any>, payloads: Input[]): Extension;
-export { defineFacetPayload }
-export { defineFacetPayload as defineFacetPayload_alias_1 }
-
-/**
- * Registers a event handler that is called when the editor gains or loses focus.
- *
- * @public
- */
-declare function defineFocusChangeHandler(handler: FocusChangeHandler): PlainExtension;
-export { defineFocusChangeHandler }
-export { defineFocusChangeHandler as defineFocusChangeHandler_alias_1 }
-
-/**
- * Add undo/redo history to the editor.
- *
- * @param options
- *
- * @public
- */
-declare function defineHistory({ depth, newGroupDelay, }?: HistoryOptions): HistoryExtension;
-export { defineHistory }
-export { defineHistory as defineHistory_alias_1 }
-
-/**
- * @public
- *
- * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleKeyDown}
- */
-declare function defineKeyDownHandler(handler: KeyDownHandler): PlainExtension;
-export { defineKeyDownHandler }
-export { defineKeyDownHandler as defineKeyDownHandler_alias_1 }
-
-/**
- * @public
- */
-declare function defineKeymap(keymap: Keymap): PlainExtension;
-export { defineKeymap }
-export { defineKeymap as defineKeymap_alias_1 }
-
-/**
- * @public
- *
- * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleKeyPress}
- */
-declare function defineKeyPressHandler(handler: KeyPressHandler): PlainExtension;
-export { defineKeyPressHandler }
-export { defineKeyPressHandler as defineKeyPressHandler_alias_1 }
-
-/**
- * @public
- */
-declare function defineMarkAttr<MarkType extends string = string, AttrName extends string = string, AttrType = any>(options: MarkAttrOptions<MarkType, AttrName, AttrType>): Extension<{
-    Marks: {
-        [K in MarkType]: AttrType;
-    };
-}>;
-export { defineMarkAttr }
-export { defineMarkAttr as defineMarkAttr_alias_1 }
-
-/**
- * @public
- */
-declare function defineMarkSpec<Mark extends string, Attrs extends AnyAttrs = AnyAttrs>(options: MarkSpecOptions<Mark, Attrs>): Extension<{
-    Marks: {
-        [K in Mark]: Attrs;
-    };
-}>;
-export { defineMarkSpec }
-export { defineMarkSpec as defineMarkSpec_alias_1 }
-
-declare function defineMarkView(options: MarkViewOptions): Extension;
-export { defineMarkView }
-export { defineMarkView as defineMarkView_alias_1 }
-
-/**
- * @internal
- */
-declare function defineMarkViewComponent<T>(options: MarkViewComponentOptions<T>): Extension;
-export { defineMarkViewComponent }
-export { defineMarkViewComponent as defineMarkViewComponent_alias_1 }
-
-/**
- * @internal
- */
-declare function defineMarkViewFactory<T>(options: MarkViewFactoryOptions<T>): Extension;
-export { defineMarkViewFactory }
-export { defineMarkViewFactory as defineMarkViewFactory_alias_1 }
-
-/**
- * Registers a event handler that is called when the editor view is mounted.
- *
- * @public
- */
-declare function defineMountHandler(handler: MountHandler): PlainExtension;
-export { defineMountHandler }
-export { defineMountHandler as defineMountHandler_alias_1 }
-
-/**
- * Defines an attribute for a node type.
- *
- * @public
- */
-declare function defineNodeAttr<NodeType extends string = string, AttrName extends string = string, AttrType = any>(options: NodeAttrOptions<NodeType, AttrName, AttrType>): Extension<{
-    Nodes: {
-        [K in NodeType]: {
-            [K in AttrName]: AttrType;
-        };
-    };
-}>;
-export { defineNodeAttr }
-export { defineNodeAttr as defineNodeAttr_alias_1 }
-
-/**
- * Defines a node type.
- *
- * @public
- */
-declare function defineNodeSpec<Node extends string, Attrs extends AnyAttrs = AnyAttrs>(options: NodeSpecOptions<Node, Attrs>): Extension<{
-    Nodes: {
-        [K in Node]: Attrs;
-    };
-}>;
-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 defineNodeViewComponent<T>(options: NodeViewComponentOptions<T>): Extension;
-export { defineNodeViewComponent }
-export { defineNodeViewComponent as defineNodeViewComponent_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.
- *
- * @deprecated Use the following import instead:
- *
- * ```ts
- * import { defineParagraph } from 'prosekit/extensions/paragraph'
- * ```
- */
-declare function defineParagraph(): ParagraphExtension;
-export { defineParagraph }
-export { defineParagraph as defineParagraph_alias_1 }
-
-/**
- * @public
- *
- * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handlePaste}
- */
-declare function definePasteHandler(handler: PasteHandler): PlainExtension;
-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[])): PlainExtension;
-export { definePlugin }
-export { definePlugin as definePlugin_alias_1 }
-
-/**
- * @public
- *
- * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleScrollToSelection}
- */
-declare function defineScrollToSelectionHandler(handler: ScrollToSelectionHandler): PlainExtension;
-export { defineScrollToSelectionHandler }
-export { defineScrollToSelectionHandler as defineScrollToSelectionHandler_alias_1 }
-
-/**
- * @public
- *
- * @deprecated Use the following import instead:
- *
- * ```ts
- * import { defineText } from 'prosekit/extensions/text'
- * ```
- */
-declare function defineText(): TextExtension;
-export { defineText }
-export { defineText as defineText_alias_1 }
-
-/**
- * @public
- *
- * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleTextInput}
- */
-declare function defineTextInputHandler(handler: TextInputHandler): PlainExtension;
-export { defineTextInputHandler }
-export { defineTextInputHandler as defineTextInputHandler_alias_1 }
-
-/**
- * @public
- *
- * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleTripleClick}
- */
-declare function defineTripleClickHandler(handler: TripleClickHandler): PlainExtension;
-export { defineTripleClickHandler }
-export { defineTripleClickHandler as defineTripleClickHandler_alias_1 }
-
-/**
- * @public
- *
- * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleTripleClickOn}
- */
-declare function defineTripleClickOnHandler(handler: TripleClickOnHandler): PlainExtension;
-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): PlainExtension;
-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): PlainExtension;
-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
- */
-declare type DocExtension = Extension<{
-    Nodes: {
-        doc: Attrs;
-    };
-}>;
-export { DocExtension }
-export { DocExtension as DocExtension_alias_1 }
-
-/**
- * @internal
- */
-export declare class DOMDocumentNotFoundError extends ProseKitError {
-    constructor();
-}
-
-/** @public */
-declare interface DOMDocumentOptions {
-    /**
-     * The Document object to use for DOM operations. If not provided, defaults to
-     * the current browser's document object. Useful for server-side rendering or
-     * testing environments.
-     */
-    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 interface DOMParserOptions extends ParseOptions {
-    DOMParser?: typeof DOMParser_2;
-}
-export { DOMParserOptions }
-export { DOMParserOptions as DOMParserOptions_alias_1 }
-
-/** @public */
-declare interface DOMSerializerOptions {
-    DOMSerializer?: {
-        fromSchema: typeof DOMSerializer.fromSchema;
-    };
-}
-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_2, 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;
-    /**
-     * @internal
-     */
-    constructor(instance: EditorInstance);
-    /**
-     * Whether the editor is mounted.
-     */
-    get mounted(): boolean;
-    /**
-     * The editor view.
-     */
-    get view(): EditorView;
-    /**
-     * The editor schema.
-     */
-    get schema(): Schema<ExtractNodeNames<E>, ExtractMarkNames<E>>;
-    /**
-     * The editor's current state.
-     */
-    get state(): EditorState;
-    /**
-     * 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;
-    /**
-     * Register an extension to the editor. Return a function to unregister the
-     * extension.
-     */
-    use: (extension: Extension) => VoidFunction;
-    /**
-     * Update the editor's state.
-     *
-     * @remarks
-     *
-     * 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;
-    /**
-     * 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;
-    /**
-     * Return a JSON object representing the editor's current document.
-     */
-    getDocJSON: () => NodeJSON;
-    /**
-     * Return a HTML string representing the editor's current document.
-     */
-    getDocHTML: (options?: getDocHTMLOptions) => string;
-    /**
-     * 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.
-     */
-    get commands(): ExtractCommandActions<E>;
-    /**
-     * All {@link NodeAction}s defined by the editor.
-     */
-    get nodes(): ExtractNodeActions<E>;
-    /**
-     * All {@link MarkAction}s defined by the editor.
-     */
-    get marks(): ExtractMarkActions<E>;
-}
-export { Editor }
-export { Editor as Editor_alias_1 }
-
-/**
- * @internal
- */
-declare const editorEventFacet: Facet<EditorEventPayload, PluginPayload>;
-export { editorEventFacet }
-export { editorEventFacet as editorEventFacet_alias_1 }
-
-declare interface EditorEventMap {
-    keyDown: KeyDownHandler;
-    keyPress: KeyPressHandler;
-    textInput: TextInputHandler;
-    clickOn: ClickOnHandler;
-    click: ClickHandler;
-    doubleClickOn: DoubleClickOnHandler;
-    doubleClick: DoubleClickHandler;
-    tripleClickOn: TripleClickOnHandler;
-    tripleClick: TripleClickHandler;
-    paste: PasteHandler;
-    drop: DropHandler;
-    scrollToSelection: ScrollToSelectionHandler;
-}
-
-/**
- * @internal
- */
-declare type EditorEventPayload = ObjectEntries<EditorEventMap>;
-export { EditorEventPayload }
-export { EditorEventPayload as EditorEventPayload_alias_1 }
-
-/**
- * An internal class to make TypeScript generic type easier to use.
- *
- * @internal
- */
-export declare class EditorInstance {
-    view: EditorView | null;
-    schema: Schema;
-    nodes: Record<string, NodeAction>;
-    marks: Record<string, MarkAction>;
-    commands: Record<string, CommandAction>;
-    private tree;
-    private directEditorProps;
-    private afterMounted;
-    constructor(extension: Extension);
-    getState: () => EditorState;
-    private getDoc;
-    private getProp;
-    updateState(state: EditorState): void;
-    private dispatch;
-    setContent(content: NodeJSON | string | HTMLElement | ProseMirrorNode, selection?: SelectionJSON | Selection_2 | 'start' | 'end'): void;
-    /**
-     * Return a JSON object representing the editor's current document.
-     */
-    getDocJSON: () => NodeJSON;
-    /**
-     * Return a HTML string representing the editor's current document.
-     */
-    getDocHTML: (options?: getDocHTMLOptions) => string;
-    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;
-}
-
-/**
- * @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;
-    /**
-     * 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 `defaultContent` 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
- *
- * @example
- *
- * ```ts
- * const json = { type: 'doc', content: [{ type: 'paragraph' }] }
- * const element = elementFromJSON(json, { schema: editor.schema })
- * ```
- */
-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
- *
- * @example
- *
- * ```ts
- * const node = editor.state.doc
- * const element = elementFromNode(node)
- * ```
- */
-declare function elementFromNode(node: ProseMirrorNode, options?: DOMSerializerOptions & DOMDocumentOptions): HTMLElement;
-export { elementFromNode }
-export { elementFromNode as elementFromNode_alias_1 }
-
-/**
- * Expands the selection to include the entire mark at the current position.
- *
- * @public
- */
-declare function expandMark(options: ExpandMarkOptions): Command;
-export { expandMark }
-export { expandMark as expandMark_alias_1 }
-
-/**
- * @public
- */
-declare interface ExpandMarkOptions {
-    /**
-     * The type of the mark to expand.
-     */
-    type: string | MarkType;
-}
-export { ExpandMarkOptions }
-export { ExpandMarkOptions as ExpandMarkOptions_alias_1 }
-
-/**
- * @public
- */
-declare interface Extension<T extends ExtensionTyping<any, any, any> = ExtensionTyping<any, any, any>> {
-    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<N extends NodeTyping | never = never, M extends MarkTyping | never = never, C extends CommandTyping | never = never> {
-    Nodes?: N;
-    Marks?: M;
-    Commands?: C;
-}
-export { ExtensionTyping }
-export { ExtensionTyping as ExtensionTyping_alias_1 }
-
-/**
- * Extracts the {@link CommandAction}s from an extension type.
- *
- * @public
- */
-declare type ExtractCommandActions<E extends Extension> = ToCommandAction<ExtractCommands<E>>;
-export { ExtractCommandActions }
-export { ExtractCommandActions as ExtractCommandActions_alias_1 }
-
-/**
- * @deprecated Use `ExtractCommandActions` instead.
- */
-declare type ExtractCommandAppliers<E extends Extension> = ExtractCommandActions<E>;
-export { ExtractCommandAppliers }
-export { ExtractCommandAppliers as ExtractCommandAppliers_alias_1 }
-
-/**
- * @public
- */
-declare type ExtractCommandCreators<E extends Extension> = ToCommandCreators<ExtractCommands<E>>;
-export { ExtractCommandCreators }
-export { ExtractCommandCreators as ExtractCommandCreators_alias_1 }
-
-/**
- * @internal
- */
-export declare type ExtractCommands<E extends Extension> = SimplifyUnion<ExtractTyping<E>['Commands']>;
-
-/**
- * Extracts the {@link MarkAction}s from an extension type.
- *
- * @public
- */
-declare type ExtractMarkActions<E extends Extension> = ToMarkAction<ExtractMarks<E>>;
-export { ExtractMarkActions }
-export { ExtractMarkActions as ExtractMarkActions_alias_1 }
-
-/**
- * @public
- */
-export declare type ExtractMarkNames<E extends Extension> = PickStringLiteral<keyof ExtractMarks<E>>;
-
-/**
- * @public
- */
-declare type ExtractMarks<E extends Extension> = SimplifyDeeper<SimplifyUnion<ExtractTyping<E>['Marks']>>;
-export { ExtractMarks }
-export { ExtractMarks as ExtractMarks_alias_1 }
-
-/**
- * Extracts the {@link NodeAction}s from an extension type.
- *
- * @public
- */
-declare type ExtractNodeActions<E extends Extension> = ToNodeAction<ExtractNodes<E>>;
-export { ExtractNodeActions }
-export { ExtractNodeActions as ExtractNodeActions_alias_1 }
-
-/**
- * @public
- */
-export declare type ExtractNodeNames<E extends Extension> = PickStringLiteral<keyof ExtractNodes<E>>;
-
-/**
- * @public
- */
-declare type ExtractNodes<E extends Extension> = SimplifyDeeper<SimplifyUnion<ExtractTyping<E>['Nodes']>>;
-export { ExtractNodes }
-export { ExtractNodes as ExtractNodes_alias_1 }
-
-export declare function extractTags(node: TaggedProseMirrorNode): Record<string, number>;
-
-/**
- * @internal
- */
-export declare type ExtractTyping<E extends Extension> = E extends Extension<ExtensionTyping<infer N, infer M, infer C>> ? ExtensionTyping<PickSubType<N, NodeTyping>, PickSubType<M, MarkTyping>, PickSubType<C, CommandTyping>> : never;
-
-/**
- * @internal
- */
-declare class Facet<Input, Output> {
-    private _reducer?;
-    private _reduce?;
-    /**
-     * @internal
-     */
-    readonly index: number;
-    /**
-     * @internal
-     */
-    readonly parent: Facet<Output, any> | null;
-    /**
-     * @internal
-     */
-    readonly singleton: boolean;
-    /**
-     * A index path to retrieve the current facet in a tree from the root.
-     *
-     * @internal
-     */
-    readonly path: number[];
-    /**
-     * @internal
-     */
-    constructor(parent: Facet<Output, any> | null, singleton: boolean, _reducer?: FacetReducer<Input, Output> | undefined, _reduce?: (() => FacetReducer<Input, Output>) | undefined);
-    get reducer(): FacetReducer<Input, Output>;
-}
-export { Facet }
-export { Facet as Facet_alias_1 }
-
-/**
- * @internal
- */
-export declare class FacetExtensionImpl<Input, Output> extends BaseExtension {
-    readonly facet: Facet<Input, Output>;
-    readonly payloads: Input[];
-    extension: Extension;
-    /**
-     * @internal
-     */
-    constructor(facet: Facet<Input, Output>, payloads: Input[]);
-    /**
-     * @internal
-     */
-    createTree(priority: Priority): FacetNode;
-}
-
-export declare class FacetNode<I = any, O = any> {
-    readonly facet: Facet<I, O>;
-    readonly inputs: Tuple5<I[] | null>;
-    readonly children: Map<number, FacetNode>;
-    readonly reducers: Tuple5<FacetReducer<I, O> | null>;
-    output: Tuple5<O | null> | null;
-    constructor(facet: Facet<I, O>, inputs?: Tuple5<I[] | null>, children?: Map<number, FacetNode>, reducers?: Tuple5<FacetReducer<I, O> | null>);
-    private calcOutput;
-    getOutput(): Tuple5<O | null>;
-    getSingletonOutput(): O | null;
-    getRootOutput(): RootOutput;
-    isRoot(): boolean;
-}
-
-/**
- * @internal
- */
-export declare type FacetReducer<Input, Output> = (input: Input[]) => Output;
-
-export declare function findBrowserDocument(options?: {
-    document?: Document;
-}): Document | undefined;
-
-export declare function findBrowserWindow(options?: {
-    document?: Document;
-}): (Window & typeof globalThis) | undefined;
-
-/**
- * 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.
- *
- * @param hasFocus - Whether the editor has focus.
- *
- * @public
- */
-declare type FocusChangeHandler = (hasFocus: boolean) => void;
-export { FocusChangeHandler }
-export { FocusChangeHandler as FocusChangeHandler_alias_1 }
-
-declare type FunctionWrapper<T extends AnyFunction> = (fn: T) => T;
-
-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_2;
-
-/**
- * @public
- */
-export declare interface getDocHTMLOptions extends DOMDocumentOptions {
-}
-
-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.
- *
- * @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 }
-
-/**
- * @internal
- */
-export declare function getNodeTypes(schema: Schema, types: string | NodeType | string[] | NodeType[]): NodeType[];
-
-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][];
-};
-
-/**
- * @internal
- */
-declare type HistoryExtension = Extension<{
-    Commands: {
-        undo: [];
-        redo: [];
-    };
-}>;
-export { HistoryExtension }
-export { HistoryExtension as HistoryExtension_alias_1 }
-
-/**
- * Options for {@link defineHistory}.
- *
- * @public
- */
-declare interface HistoryOptions {
-    /**
-     * The amount of history events that are collected before the oldest events
-     * are discarded.
-     *
-     * @default 200
-     */
-    depth?: number;
-    /**
-     * The delay in milliseconds between changes after which a new group should be
-     * started.
-     *
-     * @default 250
-     */
-    newGroupDelay?: number;
-}
-export { HistoryOptions }
-export { HistoryOptions as HistoryOptions_alias_1 }
-
-/**
- * @internal
- */
-export declare function htmlFromElement(element: HTMLElement): string;
-
-/**
- * Parse a ProseMirror document JSON object to a HTML string.
- *
- * @public
- *
- * @example
- *
- * ```ts
- * const json = { type: 'doc', content: [{ type: 'paragraph' }] }
- * const html = htmlFromJSON(json, { schema: editor.schema })
- * ```
- */
-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
- *
- * @example
- *
- * ```ts
- * const node = document.getElementById('content')
- * const html = htmlFromNode(node)
- * ```
- */
-declare function htmlFromNode(node: ProseMirrorNode, options?: DOMSerializerOptions & DOMDocumentOptions): string;
-export { htmlFromNode }
-export { htmlFromNode as htmlFromNode_alias_1 }
-
-export declare function includesMark(marks: readonly Mark[], markType: MarkType, attrs?: Attrs | null): boolean;
-
-/**
- * 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.
- *
- * @public
- */
-declare function insertNode(options: InsertNodeOptions): Command;
-export { insertNode }
-export { insertNode as insertNode_alias_1 }
-
-export declare function insertNodeAction({ node, pos, }: {
-    node: ProseMirrorNode;
-    pos?: number;
-}): Action;
-
-/**
- * @public
- */
-declare interface InsertNodeOptions {
-    /**
-     * The node to insert. Either this or `type` must be provided.
-     */
-    node?: ProseMirrorNode;
-    /**
-     * The type of the node to insert. Either this or `node` must be provided.
-     */
-    type?: string | NodeType;
-    /**
-     * When `type` is provided, the attributes of the node to insert.
-     */
-    attrs?: Attrs;
-    /**
-     * The position to insert the node at. By default it will be the anchor
-     * position of current selection.
-     */
-    pos?: number;
-}
-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.
- *
- * @public
- */
-export declare function insertText({ text, from, to }: InsertTextOptions): Command;
-
-/**
- * @public
- */
-export declare type InsertTextOptions = {
-    text: string;
-    from?: number;
-    to?: number;
-};
-
-/**
- * Checks if the given object is a `AllSelection` instance.
- *
- * @public
- */
-declare function isAllSelection(sel: Selection_2): sel is AllSelection;
-export { isAllSelection }
-export { isAllSelection as isAllSelection_alias_1 }
-
-/**
- * @private
- */
-declare const isApple: boolean;
-export { isApple }
-export { isApple as isApple_alias_1 }
-
-/**
- * Whether the selection is an empty text selection at the start of a block.
- *
- * @internal
- */
-declare function isAtBlockStart(state: EditorState, view?: EditorView): ResolvedPos | null;
-export { isAtBlockStart }
-export { isAtBlockStart as isAtBlockStart_alias_1 }
-
-/**
- * @internal
- */
-declare function isElement(el: unknown): el is Element;
-export { isElement }
-export { isElement as isElement_alias_1 }
-
-/**
- * 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.
- *
- * @internal
- */
-declare function isInCodeBlock(selection: Selection_2): boolean;
-export { isInCodeBlock }
-export { isInCodeBlock as isInCodeBlock_alias_1 }
-
-/**
- * Checks if the given object is a `Mark` instance.
- *
- * @public
- */
-declare function isMark(mark: unknown): mark is Mark;
-export { isMark }
-export { isMark as isMark_alias_1 }
-
-/**
- * Returns true if the given mark is missing in some part of the range.
- * Returns false if the entire range has the given mark.
- * Returns true if the mark is not allowed in the range.
- *
- * @internal
- */
-declare function isMarkAbsent(node: ProseMirrorNode, from: number, to: number, markType: MarkType, attrs?: Attrs | null): boolean;
-export { isMarkAbsent }
-export { isMarkAbsent as isMarkAbsent_alias_1 }
-
-/**
- * @internal
- */
-declare function isMarkActive(state: EditorState, type: string | MarkType, attrs?: Attrs | null): boolean;
-export { isMarkActive }
-export { isMarkActive as isMarkActive_alias_1 }
-
-export declare function isNodeActive(state: EditorState, type: string | NodeType, attrs?: Attrs | null): boolean;
-
-/**
- * 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 }
-
-/**
- * @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`.
- *
- * @internal
- */
-export declare function isSubset(subset: Record<string, unknown>, superset: Record<string, unknown>): boolean;
-
-/**
- * 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 }
-
-/**
- * Serialize a HTML element to a ProseMirror document JSON object.
- *
- * @public
- *
- * @example
- *
- * ```ts
- * const element = document.getElementById('content')
- * const json = jsonFromElement(element, { schema: editor.schema })
- * ```
- */
-export declare function jsonFromElement(element: DOMNode, options: DOMParserOptions & JSONParserOptions): NodeJSON;
-
-/**
- * Parse a HTML string to a ProseMirror document JSON object.
- *
- * @public
- *
- * @example
- *
- * ```ts
- * const html = '<p>Hello, world!</p>'
- * const json = jsonFromHTML(html, { schema: editor.schema })
- * ```
- */
-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
- *
- * @example
- *
- * ```ts
- * const node = editor.state.doc
- * const json = jsonFromNode(node)
- * ```
- */
-declare function jsonFromNode(node: ProseMirrorNode): NodeJSON;
-export { jsonFromNode }
-export { jsonFromNode as jsonFromNode_alias_1 }
-
-/**
- * Return a JSON object representing this state.
- *
- * @public
- *
- * @example
- *
- * ```ts
- * const state = editor.state
- * const json = jsonFromState(state)
- * ```
- */
-declare function jsonFromState(state: EditorState): StateJSON;
-export { jsonFromState }
-export { jsonFromState as jsonFromState_alias_1 }
-
-/** @public */
-declare interface JSONParserOptions {
-    /**
-     * The editor schema to use.
-     */
-    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<KeymapPayload, 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 }
-
-/**
- * A function for creating a mark with optional attributes and any number of
- * children.
- *
- * It also has a `isActive` method for checking if the mark is active in the
- * current editor selection.
- *
- * @public
- */
-declare interface MarkAction<Attrs extends AnyAttrs = AnyAttrs> {
-    (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode[];
-    (...children: NodeChild[]): ProseMirrorNode[];
-    /**
-     * Checks if the mark is active in the current editor selection. If the
-     * optional `attrs` parameter is provided, it will check if the mark is active
-     * with the given attributes.
-     */
-    isActive: (attrs?: Attrs) => boolean;
-}
-export { MarkAction }
-export { MarkAction as MarkAction_alias_1 }
-
-/**
- * @public
- */
-declare interface MarkAttrOptions<MarkName extends string = string, AttrName extends string = string, AttrType = any> extends AttrSpec<AttrType> {
-    /**
-     * The name of the mark type.
-     */
-    type: MarkName;
-    /**
-     * The name of the attribute.
-     */
-    attr: AttrName;
-    /**
-     * 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: AttrType) => [key: string, value: string] | null | undefined;
-    /**
-     * Parses the attribute value from the DOM.
-     */
-    parseDOM?: (node: HTMLElement) => AttrType;
-}
-export { MarkAttrOptions }
-export { MarkAttrOptions as MarkAttrOptions_alias_1 }
-
-/**
- * @deprecated Use type {@link MarkAction} instead.
- */
-declare type MarkBuilder = MarkAction;
-export { MarkBuilder }
-export { MarkBuilder as MarkBuilder_alias_1 }
-
-declare type MarksFromSchemaFunction = typeof DOMSerializer.marksFromSchema;
-
-/**
- * @public
- */
-declare interface MarkSpecOptions<MarkName extends string = string, Attrs extends AnyAttrs = AnyAttrs> extends MarkSpec {
-    /**
-     * The name of the mark type.
-     */
-    name: MarkName;
-    /**
-     * The attributes that marks of this type get.
-     */
-    attrs?: {
-        [K in keyof Attrs]: AttrSpec<Attrs[K]>;
-    };
-}
-export { MarkSpecOptions }
-export { MarkSpecOptions as MarkSpecOptions_alias_1 }
-
-/**
- * @internal
- */
-declare interface MarkTyping {
-    [name: string]: Record<string, any>;
-}
-export { MarkTyping }
-export { MarkTyping as MarkTyping_alias_1 }
-
-/**
- * @internal
- */
-declare type MarkViewComponentOptions<T> = {
-    group: string;
-    name: string;
-    args: T;
-};
-export { MarkViewComponentOptions }
-export { MarkViewComponentOptions as MarkViewComponentOptions_alias_1 }
-
-/**
- * @internal
- */
-declare type MarkViewFactoryOptions<T> = {
-    group: string;
-    factory: (args: T) => MarkViewConstructor;
-};
-export { MarkViewFactoryOptions }
-export { MarkViewFactoryOptions as MarkViewFactoryOptions_alias_1 }
-
-declare interface MarkViewOptions {
-    name: string;
-    constructor: MarkViewConstructor;
-}
-export { MarkViewOptions }
-export { MarkViewOptions as MarkViewOptions_alias_1 }
-
-/**
- * @internal
- */
-declare function maybeRun<MaybeFn, Result = MaybeFn extends (...args: any[]) => void ? ReturnType<MaybeFn> : MaybeFn>(value: MaybeFn, ...args: MaybeFn extends (...args: any[]) => void ? Parameters<MaybeFn> : never): Result;
-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.
- *
- * @param view - The editor view.
- *
- * @public
- */
-declare type MountHandler = (view: EditorView) => void;
-export { MountHandler }
-export { MountHandler as MountHandler_alias_1 }
-
-/**
- * A function for creating a node with optional attributes and any number of
- * children.
- *
- * It also has a `isActive` method for checking if the node is active in the
- * current editor selection.
- *
- * @public
- */
-declare interface NodeAction<Attrs extends AnyAttrs = AnyAttrs> {
-    (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode;
-    (...children: NodeChild[]): ProseMirrorNode;
-    /**
-     * Checks if the node is active in the current editor selection. If the
-     * optional `attrs` parameter is provided, it will check if the node is active
-     * with the given attributes.
-     */
-    isActive: (attrs?: Attrs) => boolean;
-}
-export { NodeAction }
-export { NodeAction as NodeAction_alias_1 }
-
-/**
- * @public
- */
-declare interface NodeAttrOptions<NodeName extends string = string, AttrName extends string = string, AttrType = any> extends AttrSpec<AttrType> {
-    /**
-     * The name of the node type.
-     */
-    type: NodeName;
-    /**
-     * The name of the attribute.
-     */
-    attr: AttrName;
-    /**
-     * Whether the attribute should be kept when the node is split. Set it to
-     * `true` if you want to inherit the attribute from the previous node when
-     * splitting the node by pressing `Enter`.
-     *
-     * @default undefined
-     */
-    splittable?: boolean;
-    /**
-     * 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: AttrType) => [key: string, value: string] | null | undefined;
-    /**
-     * Parses the attribute value from the DOM.
-     */
-    parseDOM?: (node: HTMLElement) => AttrType;
-}
-export { NodeAttrOptions }
-export { NodeAttrOptions as NodeAttrOptions_alias_1 }
-
-/**
- * @deprecated Use type {@link NodeAction} instead.
- */
-declare type NodeBuilder = NodeAction;
-export { NodeBuilder }
-export { NodeBuilder as NodeBuilder_alias_1 }
-
-/**
- * Available children parameters for {@link NodeAction} and {@link MarkAction}.
- *
- * @public
- */
-declare type NodeChild = ProseMirrorNode | string | NodeChild[];
-export { NodeChild }
-export { NodeChild as NodeChild_alias_1 }
-
-/**
- * @public
- *
- * @deprecated
- */
-declare type NodeContent = ProseMirrorNode | ProseMirrorFragment | NodeContent[];
-export { NodeContent }
-export { NodeContent as NodeContent_alias_1 }
-
-/**
- * Parse a HTML element to a ProseMirror node.
- *
- * @public
- *
- * @example
- *
- * ```ts
- * const element = document.getElementById('content')
- * const node = nodeFromElement(element, { schema: editor.schema })
- */
-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
- *
- * @example
- *
- * ```ts
- * const html = '<p>Hello, world!</p>'
- * const node = nodeFromHTML(html, { schema: editor.schema })
- */
-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
- *
- * @example
- *
- * ```ts
- * const json = { type: 'doc', content: [{ type: 'paragraph' }] }
- * const node = nodeFromJSON(json, { schema: editor.schema })
- * ```
- */
-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<{
-        type: string;
-        attrs?: Record<string, any>;
-    }>;
-    text?: string;
-    content?: NodeJSON[];
-    attrs?: Record<string, any>;
-}
-export { NodeJSON }
-export { NodeJSON as NodeJSON_alias_1 }
-
-declare type NodesFromSchemaFunction = typeof DOMSerializer.nodesFromSchema;
-
-/**
- * @public
- */
-declare interface NodeSpecOptions<NodeName extends string = string, Attrs extends AnyAttrs = AnyAttrs> extends NodeSpec {
-    /**
-     * The name of the node type.
-     */
-    name: NodeName;
-    /**
-     * Whether this is the top-level node type. Only one node type can be the
-     * top-level node type in a schema.
-     */
-    topNode?: boolean;
-    /**
-     * The attributes that nodes of this type get.
-     */
-    attrs?: {
-        [key in keyof Attrs]: AttrSpec<Attrs[key]>;
-    };
-}
-export { NodeSpecOptions }
-export { NodeSpecOptions as NodeSpecOptions_alias_1 }
-
-/**
- * @internal
- */
-declare interface NodeTyping {
-    [name: string]: Record<string, any>;
-}
-export { NodeTyping }
-export { NodeTyping as NodeTyping_alias_1 }
-
-/**
- * @internal
- */
-declare type NodeViewComponentOptions<T> = {
-    group: string;
-    name: string;
-    args: T;
-};
-export { NodeViewComponentOptions }
-export { NodeViewComponentOptions as NodeViewComponentOptions_alias_1 }
-
-/**
- * @internal
- */
-declare type NodeViewFactoryOptions<T> = {
-    group: string;
-    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;
-
-/**
- * @internal
- *
- * @deprecated Use the following import instead:
- *
- * ```ts
- * import type { ParagraphExtension } from 'prosekit/extensions/paragraph'
- * ```
- */
-declare type ParagraphExtension = ParagraphSpecExtension;
-export { ParagraphExtension }
-export { ParagraphExtension as ParagraphExtension_alias_1 }
-
-/**
- * @internal
- */
-declare type ParagraphSpecExtension = Extension<{
-    Nodes: {
-        paragraph: Attrs;
-    };
-}>;
-
-declare type PasteHandler = (view: EditorView, event: ClipboardEvent, slice: Slice) => boolean | void;
-export { PasteHandler }
-export { PasteHandler as PasteHandler_alias_1 }
-
-/**
- * @internal
- */
-export declare type Payloads<T> = Tuple5<T[]>;
-
-/**
- * @internal
- */
-export declare type PickStringLiteral<T> = PickSubType<T, string>;
-
-/**
- * @internal
- */
-declare type PickSubType<Type, ParentType> = Type extends ParentType ? [ParentType] extends [Type] ? never : Type : never;
-export { PickSubType }
-export { PickSubType as PickSubType_alias_1 }
-
-/**
- * An extension that does not define any nodes, marks, or commands.
- *
- * @internal
- */
-declare type PlainExtension = Extension<{
-    Nodes: never;
-    Marks: never;
-    Commands: never;
-}>;
-export { PlainExtension }
-export { PlainExtension as PlainExtension_alias_1 }
-
-/**
- * @internal
- */
-declare const pluginFacet: Facet<PluginPayload, StatePayload>;
-export { pluginFacet }
-export { pluginFacet as pluginFacet_alias_1 }
-
-/**
- * @internal
- */
-declare type PluginPayload = Plugin_2 | Plugin_2[] | ((context: {
-    schema: Schema;
-}) => Plugin_2 | Plugin_2[]);
-export { PluginPayload }
-export { PluginPayload as PluginPayload_alias_1 }
-
-/**
- * ProseKit extension priority.
- *
- * @public
- */
-declare enum Priority {
-    lowest = 0,
-    low = 1,
-    default = 2,
-    high = 3,
-    highest = 4
-}
-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: RemoveMarkOptions): Command;
-export { removeMark }
-export { removeMark as removeMark_alias_1 }
-
-/**
- * @public
- */
-declare interface RemoveMarkOptions {
-    /**
-     * 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;
-}
-export { RemoveMarkOptions }
-export { RemoveMarkOptions as RemoveMarkOptions_alias_1 }
-
-/**
- * Returns a command to remove the nearest ancestor node of a specific type from the current position.
- *
- * @public
- */
-declare function removeNode(options: RemoveNodeOptions): Command;
-export { removeNode }
-export { removeNode as removeNode_alias_1 }
-
-/**
- * @public
- */
-declare interface RemoveNodeOptions {
-    /**
-     * The type of the node to remove.
-     */
-    type: string | NodeType;
-    /**
-     * 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 = {
-    schema?: Schema | null;
-    commands?: CommandCreators;
-    state?: EditorStateConfig;
-    view?: Omit<DirectEditorProps, 'state'>;
-};
-
-export declare type RootPayload = {
-    schema?: Schema | null;
-    commands?: CommandCreators;
-    state?: (ctx: {
-        schema: Schema;
-    }) => EditorStateConfig;
-    view?: Omit<DirectEditorProps, 'state'>;
-};
-
-export declare const schemaFacet: Facet<SchemaSpec, RootPayload>;
-
-export declare const schemaSpecFacet: Facet<SchemaSpec, 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 }
-
-declare type SerializeFragmentFunction = typeof DOMSerializer.prototype.serializeFragment;
-
-declare type SerializeNodeFunction = typeof DOMSerializer.prototype.serializeNode;
-
-/**
- * Returns a command that tries to set the selected textblocks to the given node
- * type with the given attributes.
- *
- * @public
- */
-declare function setBlockType(options: SetBlockTypeOptions): Command;
-export { setBlockType }
-export { setBlockType as setBlockType_alias_1 }
-
-/**
- * @public
- */
-declare interface SetBlockTypeOptions {
-    type: NodeType | string;
-    attrs?: Attrs | null;
-    from?: number;
-    to?: number;
-}
-export { SetBlockTypeOptions }
-export { SetBlockTypeOptions as SetBlockTypeOptions_alias_1 }
-
-/**
- * Returns a command that set the attributes of the current node.
- *
- * @public
- */
-declare function setNodeAttrs(options: SetNodeAttrsOptions): Command;
-export { setNodeAttrs }
-export { setNodeAttrs as setNodeAttrs_alias_1 }
-
-/**
- * @public
- */
-declare interface SetNodeAttrsOptions {
-    /**
-     * 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 | 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;
-}
-export { SetNodeAttrsOptions }
-export { SetNodeAttrsOptions as SetNodeAttrsOptions_alias_1 }
-
-declare function setSelectionAround(tr: Transaction, pos: number): void;
-export { setSelectionAround }
-export { setSelectionAround as setSelectionAround_alias_1 }
-
-/**
- * @internal
- */
-export declare type Setter<T> = (value: T) => void;
-
-/**
- * @internal
- */
-export declare function setupEditorExtension<E extends Extension>(options: EditorOptions<E>): E;
-
-/**
- * @internal
- */
-declare type SimplifyDeeper<T> = {
-    [KeyType in keyof T]: Simplify<T[KeyType]>;
-};
-export { SimplifyDeeper }
-export { SimplifyDeeper as SimplifyDeeper_alias_1 }
-
-/**
- * @internal
- */
-declare type SimplifyUnion<T> = Simplify<UnionToIntersection<T extends undefined ? never : T>>;
-export { SimplifyUnion }
-export { SimplifyUnion as SimplifyUnion_alias_1 }
-
-export declare const stateFacet: Facet<StatePayload, RootPayload>;
-
-/**
- * Parse a JSON object to a ProseMirror state.
- *
- * @public
- *
- * @example
- *
- * ```ts
- * const json = { state: { type: 'doc', content: [{ type: 'paragraph' }], selection: { type: 'text', from: 1, to: 1 } } }
- * const state = stateFromJSON(json, { schema: editor.schema })
- * ```
- */
-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;
-
-/**
- * A JSON representation of the prosemirror step.
- *
- * @public
- */
-declare interface StepJSON {
-    /**
-     * The type of the step.
-     */
-    stepType: string;
-    [x: string]: unknown;
-}
-export { StepJSON }
-export { StepJSON as StepJSON_alias_1 }
-
-/**
- * Takes two facet nodes and returns a new facet node containing inputs and
- * children from the first node but not the second.
- *
- * The reducers of the first facet node will be reused.
- *
- * @internal
- */
-export declare function subtractFacetNode<I, O>(a: FacetNode<I, O>, b: FacetNode<I, O>): FacetNode<I, O>;
-
-export declare type TaggedProseMirrorNode = ProseMirrorNode & {
-    tags?: Tags;
-};
-
-declare type Tags = Record<string, number>;
-
-/**
- * An editor for testing purposes.
- * @public
- */
-declare class TestEditor<E extends Extension = Extension> extends Editor<E> {
-    constructor(instance: EditorInstance);
-    /**
-     * Set the editor state to the given document. You can use special tokens
-     * `<a>` and `<b>` to set the anchor and head positions of the selection.
-     *
-     * @example
-     *
-     * ```ts
-     * const editor = createTestEditor({ extension })
-     * const n = editor.nodes
-     * const doc = n.doc(n.paragraph('<a>Hello<b> world!'))
-     * editor.set(doc) // "Hello" is selected.
-     * ```
-     */
-    set(doc: ProseMirrorNode): void;
-    dispatchEvent(event: Event): void;
-}
-export { TestEditor }
-export { TestEditor as TestEditor_alias_1 }
-
-/**
- * @internal
- */
-declare type TextExtension = Extension<{
-    Nodes: {
-        text: Attrs;
-    };
-}>;
-export { TextExtension }
-export { TextExtension as TextExtension_alias_1 }
-
-declare type TextInputHandler = (view: EditorView, from: number, to: number, text: string) => boolean | void;
-export { TextInputHandler }
-export { TextInputHandler as TextInputHandler_alias_1 }
-
-export declare type ToCommandAction<T extends CommandTyping> = {
-    [K in keyof T]: CommandAction<T[K]>;
-};
-
-export declare type ToCommandCreators<T extends CommandTyping> = {
-    [K in keyof T]: CommandCreator<T[K]>;
-};
-
-/**
- * Returns a command that toggles the given mark with the given attributes.
- *
- * @param options
- *
- * @public
- */
-declare function toggleMark({ type, attrs, removeWhenPresent, enterInlineAtoms, }: ToggleMarkOptions): Command;
-export { toggleMark }
-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 }
-
-/**
- * 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;
-export { toggleNode }
-export { toggleNode as toggleNode_alias_1 }
-
-/**
- * @public
- */
-declare interface ToggleNodeOptions {
-    /**
-     * The type of the node to toggle.
-     */
-    type: string | NodeType;
-    /**
-     * The attributes of the node to toggle.
-     */
-    attrs?: Attrs | null;
-}
-export { ToggleNodeOptions }
-export { ToggleNodeOptions as ToggleNodeOptions_alias_1 }
-
-/**
- * Toggle between wrapping an inactive node with the provided node type, and
- * lifting it up into it's parent.
- *
- * @param options
- *
- * @public
- */
-declare function toggleWrap(options: ToggleWrapOptions): Command;
-export { toggleWrap }
-export { toggleWrap as toggleWrap_alias_1 }
-
-declare interface ToggleWrapOptions {
-    /**
-     * The type of the node to toggle.
-     */
-    type: string | NodeType;
-    /**
-     * The attributes of the node to toggle.
-     */
-    attrs?: Attrs | null;
-}
-export { ToggleWrapOptions }
-export { ToggleWrapOptions as ToggleWrapOptions_alias_1 }
-
-/**
- * @internal
- */
-declare type ToMarkAction<T extends MarkTyping> = {
-    [K in keyof T]: MarkAction<T[K]>;
-};
-export { ToMarkAction }
-export { ToMarkAction as ToMarkAction_alias_1 }
-
-/**
- * @internal
- */
-declare type ToNodeAction<T extends NodeTyping> = {
-    [K in keyof T]: NodeAction<T[K]>;
-};
-export { ToNodeAction }
-export { ToNodeAction as ToNodeAction_alias_1 }
-
-export declare function toReversed<T>(arr: T[]): T[];
-
-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_2, nodePos: number, event: MouseEvent, direct: boolean) => boolean | void;
-export { TripleClickOnHandler }
-export { TripleClickOnHandler as TripleClickOnHandler_alias_1 }
-
-/**
- * @internal
- */
-export declare type Tuple5<T> = [T, T, T, T, T];
-
-/**
- * @internal
- */
-declare type Union<E extends readonly Extension[]> = Extension<{
-    Nodes: ExtractNodes<E[number]>;
-    Marks: ExtractMarks<E[number]>;
-    Commands: ExtractCommands<E[number]>;
-}>;
-export { Union }
-export { Union as Union_alias_1 }
-
-/**
- * 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.
- *
- * @example
- *
- * ```ts
- * function defineFancyNodes() {
- *   return union(
- *     defineFancyParagraph(),
- *     defineFancyHeading(),
- *   )
- * }
- * ```
- *
- * @example
- *
- * ```ts
- * function defineFancyNodes() {
- *   return union([
- *     defineFancyParagraph(),
- *     defineFancyHeading(),
- *   ])
- * }
- * ```
- *
- * @public
- */
-declare function union<const E extends readonly Extension[]>(...exts: E): Union<E>;
-
-declare function union<const E extends readonly Extension[]>(exts: E): Union<E>;
-export { union }
-export { union as union_alias_1 }
-
-/**
- * @deprecated Use `Union` instead.
- * @internal
- */
-declare type UnionExtension<E extends Extension | readonly Extension[]> = E extends readonly Extension[] ? Extension<{
-    Nodes: ExtractNodes<E[number]>;
-    Marks: ExtractMarks<E[number]>;
-    Commands: ExtractCommands<E[number]>;
-}> : E;
-export { UnionExtension }
-export { UnionExtension as UnionExtension_alias_1 }
-
-export declare class UnionExtensionImpl<T extends ExtensionTyping = ExtensionTyping> extends BaseExtension<T> implements Extension<T> {
-    extension: BaseExtension[];
-    /**
-     * @internal
-     */
-    constructor(extension?: BaseExtension[]);
-    /**
-     * @internal
-     */
-    createTree(priority: Priority): FacetNode;
-}
-
-/**
- * Takes two facet nodes and returns a new facet node containing inputs and
- * children from both nodes.
- *
- * The reducers of the first facet node will be reused.
- *
- * @internal
- */
-export declare function unionFacetNode<I, O>(a: FacetNode<I, O>, b: FacetNode<I, O>): FacetNode<I, O>;
-
-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 }
-
-/**
- * Returns a command that set the type of all textblocks between the given range
- * to the default type (usually `paragraph`).
- *
- * @public
- */
-declare function unsetBlockType(options?: UnsetBlockTypeOptions): Command;
-export { unsetBlockType }
-export { unsetBlockType as unsetBlockType_alias_1 }
-
-/**
- * @public
- */
-declare interface UnsetBlockTypeOptions {
-    /**
-     * 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;
-}
-export { UnsetBlockTypeOptions }
-export { UnsetBlockTypeOptions as UnsetBlockTypeOptions_alias_1 }
-
-/**
- * Returns a command that removes all marks.
- *
- * @public
- */
-declare function unsetMark(options?: UnsetMarkOptions): Command;
-export { unsetMark }
-export { unsetMark as unsetMark_alias_1 }
-
-/**
- * @public
- */
-declare interface UnsetMarkOptions {
-    /**
-     * 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;
-}
-export { UnsetMarkOptions }
-export { UnsetMarkOptions as UnsetMarkOptions_alias_1 }
-
-/**
- * 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, RootPayload>;
-
-export declare type ViewPayload = Omit<DirectEditorProps, 'state'>;
-
-export declare function voidFunction(): void;
-
-/**
- * Return an new extension with the given priority.
- *
- * @example
- * ```ts
- * import { Priority, withPriority } from 'prosekit/core'
- *
- * const extension = withPriority(defineMyExtension(), Priority.high)
- * ```
- *
- * @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.
- *
- * @param options
- *
- * @public
- */
-declare function wrap(options: WrapOptions): Command;
-export { wrap }
-export { wrap as wrap_alias_1 }
-
-/**
- * @public
- */
-declare interface WrapOptions {
-    /**
-     * 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 { }