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

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

@@ -0,0 +1,1022 @@
+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 { DirectEditorProps } from '@prosekit/pm/view';
+import { EditorState } from '@prosekit/pm/state';
+import type { EditorStateConfig } from '@prosekit/pm/state';
+import { EditorView } from '@prosekit/pm/view';
+import type { EmptyObject } from 'type-fest';
+import { InputRule } from '@prosekit/pm/inputrules';
+import type { IsEqual } from 'type-fest';
+import { Mark } from '@prosekit/pm/model';
+import type { MarkSpec } from '@prosekit/pm/model';
+import { MarkType } from '@prosekit/pm/model';
+import { MarkType as MarkType_2 } from 'prosemirror-model';
+import { Node as Node_2 } from 'prosemirror-model';
+import { 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 { 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 { TextSelection } from '@prosekit/pm/state';
+import { Transaction } from '@prosekit/pm/state';
+import type { UnionToIntersection } from 'type-fest';
+import { UserProjectConfigExport } from 'vitest/dist/config.js';
+
+declare type Action = (options: {
+    tr: Transaction;
+    view?: EditorView;
+}) => boolean;
+
+/**
+ * Add the given mark to the inline content.
+ */
+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;
+}
+
+export declare function collectNodes(content: NodeContent): ProseMirrorNode[];
+
+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>({ extension, defaultDoc, defaultHTML, defaultSelection, }: 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: UserProjectConfigExport;
+
+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;
+        }];
+        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 }
+
+/**
+ * @public
+ */
+declare function defineBaseKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineBaseKeymap }
+export { defineBaseKeymap as defineBaseKeymap_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 }
+
+/**
+ * Add undo/redo history to the editor.
+ */
+declare function defineHistory(): Extension<    {
+COMMAND_ARGS: {
+undo: [];
+redo: [];
+};
+}>;
+export { defineHistory }
+export { defineHistory as defineHistory_alias_1 }
+
+/**
+ * Defines an input rule extension.
+ *
+ * @param rule - The ProseMirror input rule to add, or an array of input rules,
+ * or a function that returns one or multiple input rules.
+ *
+ * @public
+ */
+declare function defineInputRule(rule: InputRule | InputRule[] | ((context: {
+    schema: Schema;
+}) => InputRule | InputRule[])): Extension;
+export { defineInputRule }
+export { defineInputRule as defineInputRule_alias_1 }
+
+/**
+ * @public
+ */
+declare function defineKeymap(keymap: Keymap): Extension;
+export { defineKeymap }
+export { defineKeymap as defineKeymap_alias_1 }
+
+/**
+ * @public
+ */
+declare function defineMarkSpec<Mark extends string>(options: MarkSpecOptions<Mark>): Extension<{
+    MARKS: Mark;
+}>;
+export { defineMarkSpec }
+export { defineMarkSpec as defineMarkSpec_alias_1 }
+
+/**
+ * @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 }
+
+declare function defineNodeViewEffect(options: NodeViewEffectOptions): Extension;
+export { defineNodeViewEffect }
+export { defineNodeViewEffect as defineNodeViewEffect_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";
+}>;
+
+/**
+ * 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
+ */
+declare function defineText(): Extension<    {
+NODES: "text";
+}>;
+export { defineText }
+export { defineText as defineText_alias_1 }
+
+/**
+ * @internal
+ */
+declare function defineUpdateHandler(handler: UpdateHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineUpdateHandler }
+export { defineUpdateHandler as defineUpdateHandler_alias_1 }
+
+/**
+ * @public
+ */
+declare class Editor<E extends Extension = any> {
+    private instance;
+    private constructor();
+    private afterMounted;
+    /**
+     * @internal
+     */
+    static create(instance: any): Editor<any>;
+    get mounted(): boolean;
+    get view(): EditorView;
+    get schema(): Schema<ExtractNodes<E>, ExtractMarks<E>>;
+    get commands(): ExtractCommandAppliers<E>;
+    mount(place: HTMLElement | null | undefined | void): void;
+    unmount(): void;
+    use(extension: Extension): VoidFunction;
+    /**
+     * @deprecated
+     */
+    isNodeActive(nodeType: string | NodeType, attrs?: Attrs): boolean;
+    /**
+     * @deprecated
+     */
+    isMarkActive(markType: string | MarkType, attrs?: Attrs): boolean;
+    get nodes(): Record<ExtractNodes<E>, NodeBuilder>;
+    get marks(): Record<ExtractMarks<E>, MarkBuilder>;
+}
+export { Editor }
+export { Editor as Editor_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): HTMLElement;
+
+declare type EmptyValue = undefined | null | EmptyObject;
+
+export declare type ExceptEmptyValue<T> = ConditionalExcept<T, EmptyValue>;
+
+/**
+ * @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 getBrowserDocument(): Document | undefined;
+
+export declare function getBrowserWindow(): (Window & typeof globalThis) | null | undefined;
+
+export declare function getCustomSelection(state: EditorState, from?: number | null, to?: number | null): Selection_3;
+
+export declare function getFacetCount(): number;
+
+/**
+ * @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 }
+
+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;
+
+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 const isMac: boolean;
+
+/**
+ * @internal
+ */
+declare function isMark(mark: unknown): mark is Mark;
+export { isMark }
+export { isMark as isMark_alias_1 }
+
+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 }
+
+/**
+ * Parse a HTML element to a ProseMirror document JSON.
+ *
+ * @public
+ */
+declare function jsonFromElement(element: HTMLElement, schema: Schema): NodeJSON;
+export { jsonFromElement }
+export { jsonFromElement as jsonFromElement_alias_1 }
+
+/**
+ * Parse a HTML string to a ProseMirror document JSON.
+ *
+ * @public
+ */
+declare function jsonFromHTML(html: string, schema: Schema): 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 interface Keymap {
+    [key: string]: Command;
+}
+export { Keymap }
+export { Keymap as Keymap_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 }
+
+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: HTMLElement, schema: Schema): ProseMirrorNode;
+export { nodeFromElement }
+export { nodeFromElement as nodeFromElement_alias_1 }
+
+/**
+ * Parse a HTML string to a ProseMirror node.
+ *
+ * @public
+ */
+declare function nodeFromHTML(html: string, schema: Schema): ProseMirrorNode;
+export { nodeFromHTML }
+export { nodeFromHTML as nodeFromHTML_alias_1 }
+
+/**
+ * Parse a JSON object to a ProseMirror node.
+ *
+ * @public
+ */
+declare function nodeFromJSON(json: NodeJSON, schema: Schema): 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 }
+
+declare type NodeViewEffectOptions = {
+    group: string;
+    name: string;
+    args: unknown;
+} | {
+    group: string;
+    name?: undefined;
+    factory: (args: unknown) => NodeViewConstructor;
+};
+export { NodeViewEffectOptions }
+export { NodeViewEffectOptions as NodeViewEffectOptions_alias_1 }
+
+declare interface NodeViewOptions {
+    name: string;
+    constructor: NodeViewConstructor;
+}
+export { NodeViewOptions }
+export { NodeViewOptions as NodeViewOptions_alias_1 }
+
+export declare function objectEqual<T>(a: T, b: T): boolean;
+
+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 }
+
+/**
+ * @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.
+ */
+declare class ProseKitError extends Error {
+}
+export { ProseKitError }
+export { ProseKitError as ProseKitError_alias_1 }
+
+/**
+ * Remove the given mark from the inline content.
+ */
+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;
+
+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.
+ */
+declare function setBlockType(options: {
+    type: NodeType | string;
+    attrs?: Attrs | null;
+    from?: number;
+    to?: number;
+}): Command;
+export { setBlockType }
+export { setBlockType as setBlockType_alias_1 }
+
+/**
+ * @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, schema: Schema): 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;
+
+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]>;
+};
+
+declare function toggleMark({ type, attrs, }: {
+    type: string | MarkType;
+    attrs?: Attrs | null;
+}): Command;
+export { toggleMark }
+export { toggleMark as toggleMark_alias_1 }
+
+declare function toggleNode({ type, attrs, }: {
+    type: string | NodeType;
+    attrs?: Attrs | null;
+}): Command;
+export { toggleNode }
+export { toggleNode as toggleNode_alias_1 }
+
+declare type Tuple5<T> = [T, T, T, T, T];
+
+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[];
+
+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;
+};
+
+export declare type UpdateHandler = (options: {
+    view: EditorView;
+    prevState?: EditorState;
+}) => void;
+
+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 }
+
+export declare function wrap({ nodeType, attrs, }: {
+    nodeType: NodeType;
+    attrs?: Attrs | null;
+}): Command;
+
+export { }