@prosekit/core 0.0.0-next-20240505104851 → 0.0.0-next-20240531032056

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

@@ -2,7 +2,6 @@ import { AllSelection } from '@prosekit/pm/state';
 import { Attrs } from '@prosekit/pm/model';
 import { Attrs as Attrs_2 } from 'prosemirror-model';
 import { Command } from '@prosekit/pm/state';
-import type { ConditionalExcept } from 'type-fest';
 import type { ContentMatch } from '@prosekit/pm/model';
 import type { DirectEditorProps } from '@prosekit/pm/view';
 import type { DOMEventMap } from '@prosekit/pm/view';
@@ -11,7 +10,6 @@ import { DOMSerializer } from '@prosekit/pm/model';
 import { EditorState } from '@prosekit/pm/state';
 import type { EditorStateConfig } from '@prosekit/pm/state';
 import { EditorView } from '@prosekit/pm/view';
-import type { EmptyObject } from 'type-fest';
 import type { IsEqual } from 'type-fest';
 import { Mark } from '@prosekit/pm/model';
 import type { MarkSpec } from '@prosekit/pm/model';
@@ -30,7 +28,7 @@ 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 { 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';
@@ -72,6 +70,23 @@ export { addMark as addMark_alias_1 }
 
 export declare function applyAction(operator: Action): Command;
 
+/**
+ * @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.
  */
@@ -79,26 +94,27 @@ export declare function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void;
 
 export declare function attrsMatch(nodeOrMark: ProseMirrorNode | Mark, attrs: Attrs): boolean;
 
+/**
+ * @internal
+ */
 export declare abstract class BaseExtension<T extends ExtensionTyping = ExtensionTyping> implements Extension<T> {
     extension: Extension | Extension[];
     priority?: Priority;
     _type?: T;
+    private trees;
     /**
      * @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;
+    abstract createTree(priority: Priority): FacetNode;
     /**
      * @internal
-     *
-     * The schema that this extension represents.
      */
-    abstract schema: Schema | null;
+    getTree(priority?: Priority): FacetNode;
+    /**
+     * @internal
+     */
+    findFacetOutput<I, O>(facet: Facet<I, O>): Tuple5<O | null> | null;
+    get schema(): Schema | null;
 }
 
 /**
@@ -165,28 +181,24 @@ export declare interface CommandApplier<Args extends any[] = any[]> {
     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 const commandFacet: Facet<CommandCreators, RootPayload>;
 
 export declare type CommandPayload = CommandCreators;
 
-export declare type Converters = ConverterTuple[];
-
-declare type ConverterTuple = Tuple5<FacetConverter | undefined>;
+/**
+ * @internal
+ */
+declare interface CommandTyping {
+    [name: string]: any[];
+}
+export { CommandTyping }
+export { CommandTyping as CommandTyping_alias_1 }
 
 /**
  * @public
@@ -199,6 +211,8 @@ export declare function createMarkBuilder(getState: () => EditorState | null | u
 
 export declare function createNodeBuilder(getState: () => EditorState | null | undefined, type: NodeType): NodeBuilder;
 
+export declare function deepEquals<T>(a: T, b: T): boolean;
+
 export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
 
 export declare const default_alias_1: {
@@ -240,7 +254,7 @@ export { DefaultStateOptions as DefaultStateOptions_alias_1 }
  * @public
  */
 declare function defineBaseCommands(): Extension<{
-    COMMAND_ARGS: {
+    Commands: {
         insertText: [{
             text: string;
             from?: number | undefined;
@@ -268,7 +282,7 @@ declare function defineBaseCommands(): Extension<{
             to?: number | undefined;
         }];
         setNodeAttrs: [options: {
-            type: string | NodeType_2;
+            type: string | NodeType_2 | string[] | NodeType_2[];
             attrs: Attrs_2;
             pos?: number | undefined;
         }];
@@ -286,6 +300,8 @@ declare function defineBaseCommands(): Extension<{
             to?: number | undefined;
         }];
     };
+    Nodes: never;
+    Marks: never;
 }>;
 export { defineBaseCommands }
 export { defineBaseCommands as defineBaseCommands_alias_1 }
@@ -302,7 +318,7 @@ declare function defineBaseKeymap(options?: {
      * @default Priority.low
      */
     priority?: Priority;
-}): Extension<ExtensionTyping<string, string, CommandArgs>>;
+}): Extension<any>;
 export { defineBaseKeymap }
 export { defineBaseKeymap as defineBaseKeymap_alias_1 }
 
@@ -311,7 +327,7 @@ export { defineBaseKeymap as defineBaseKeymap_alias_1 }
  *
  * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleClick}
  */
-declare function defineClickHandler(handler: ClickHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineClickHandler(handler: ClickHandler): Extension<any>;
 export { defineClickHandler }
 export { defineClickHandler as defineClickHandler_alias_1 }
 
@@ -320,14 +336,16 @@ export { defineClickHandler as defineClickHandler_alias_1 }
  *
  * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleClickOn}
  */
-declare function defineClickOnHandler(handler: ClickOnHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineClickOnHandler(handler: ClickOnHandler): Extension<any>;
 export { defineClickOnHandler }
 export { defineClickOnHandler as defineClickOnHandler_alias_1 }
 
 declare function defineCommands<T extends Record<string, CommandCreator> = Record<string, CommandCreator>>(commands: T): Extension<{
-    COMMAND_ARGS: {
+    Commands: {
         [K in keyof T]: Parameters<T[K]>;
     };
+    Nodes: never;
+    Marks: never;
 }>;
 export { defineCommands }
 export { defineCommands as defineCommands_alias_1 }
@@ -340,7 +358,9 @@ export { defineDefaultState as defineDefaultState_alias_1 }
  * @public
  */
 declare function defineDoc(): Extension<    {
-NODES: "doc";
+Nodes: "doc";
+Marks: never;
+Commands: never;
 }>;
 export { defineDoc }
 export { defineDoc as defineDoc_alias_1 }
@@ -350,7 +370,7 @@ export { defineDoc as defineDoc_alias_1 }
  *
  * @public
  */
-declare function defineDocChangeHandler(handler: DocChangeHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineDocChangeHandler(handler: DocChangeHandler): Extension<any>;
 export { defineDocChangeHandler }
 export { defineDocChangeHandler as defineDocChangeHandler_alias_1 }
 
@@ -359,7 +379,7 @@ export { defineDocChangeHandler as defineDocChangeHandler_alias_1 }
  *
  * @public
  */
-declare function defineDOMEventHandler<Event extends keyof DOMEventMap = string>(event: Event, handler: DOMEventHandler<Event>): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineDOMEventHandler<Event extends keyof DOMEventMap = string>(event: Event, handler: DOMEventHandler<Event>): Extension<any>;
 export { defineDOMEventHandler }
 export { defineDOMEventHandler as defineDOMEventHandler_alias_1 }
 
@@ -368,7 +388,7 @@ export { defineDOMEventHandler as defineDOMEventHandler_alias_1 }
  *
  * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleDoubleClick}
  */
-declare function defineDoubleClickHandler(handler: DoubleClickHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineDoubleClickHandler(handler: DoubleClickHandler): Extension<any>;
 export { defineDoubleClickHandler }
 export { defineDoubleClickHandler as defineDoubleClickHandler_alias_1 }
 
@@ -377,7 +397,7 @@ export { defineDoubleClickHandler as defineDoubleClickHandler_alias_1 }
  *
  * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleDoubleClickOn}
  */
-declare function defineDoubleClickOnHandler(handler: DoubleClickOnHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineDoubleClickOnHandler(handler: DoubleClickOnHandler): Extension<any>;
 export { defineDoubleClickOnHandler }
 export { defineDoubleClickOnHandler as defineDoubleClickOnHandler_alias_1 }
 
@@ -386,16 +406,50 @@ export { defineDoubleClickOnHandler as defineDoubleClickOnHandler_alias_1 }
  *
  * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleDrop}
  */
-declare function defineDropHandler(handler: DropHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineDropHandler(handler: DropHandler): Extension<any>;
 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): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineFocusChangeHandler(handler: FocusChangeHandler): Extension<any>;
 export { defineFocusChangeHandler }
 export { defineFocusChangeHandler as defineFocusChangeHandler_alias_1 }
 
@@ -403,9 +457,10 @@ export { defineFocusChangeHandler as defineFocusChangeHandler_alias_1 }
  * Add undo/redo history to the editor.
  */
 declare function defineHistory(): Extension<    {
-COMMAND_ARGS: {
-undo: [];
-redo: [];
+Nodes: any;
+Marks: any;
+Commands: {
+[x: string]: any;
 };
 }>;
 export { defineHistory }
@@ -416,7 +471,7 @@ export { defineHistory as defineHistory_alias_1 }
  *
  * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleKeyDown}
  */
-declare function defineKeyDownHandler(handler: KeyDownHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineKeyDownHandler(handler: KeyDownHandler): Extension<any>;
 export { defineKeyDownHandler }
 export { defineKeyDownHandler as defineKeyDownHandler_alias_1 }
 
@@ -432,7 +487,7 @@ export { defineKeymap as defineKeymap_alias_1 }
  *
  * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleKeyPress}
  */
-declare function defineKeyPressHandler(handler: KeyPressHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineKeyPressHandler(handler: KeyPressHandler): Extension<any>;
 export { defineKeyPressHandler }
 export { defineKeyPressHandler as defineKeyPressHandler_alias_1 }
 
@@ -447,7 +502,9 @@ export { defineMarkAttr as defineMarkAttr_alias_1 }
  * @public
  */
 declare function defineMarkSpec<Mark extends string>(options: MarkSpecOptions<Mark>): Extension<{
-    MARKS: Mark;
+    Marks: Mark;
+    Nodes: never;
+    Commands: never;
 }>;
 export { defineMarkSpec }
 export { defineMarkSpec as defineMarkSpec_alias_1 }
@@ -457,7 +514,7 @@ export { defineMarkSpec as defineMarkSpec_alias_1 }
  *
  * @public
  */
-declare function defineMountHandler(handler: MountHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineMountHandler(handler: MountHandler): Extension<any>;
 export { defineMountHandler }
 export { defineMountHandler as defineMountHandler_alias_1 }
 
@@ -475,8 +532,10 @@ export { defineNodeAttr as defineNodeAttr_alias_1 }
  *
  * @public
  */
-declare function defineNodeSpec<NodeName extends string>(options: NodeSpecOptions<NodeName>): Extension<{
-    NODES: NodeName;
+declare function defineNodeSpec<Node extends string>(options: NodeSpecOptions<Node>): Extension<{
+    Nodes: Node;
+    Marks: never;
+    Commands: never;
 }>;
 export { defineNodeSpec }
 export { defineNodeSpec as defineNodeSpec_alias_1 }
@@ -498,7 +557,9 @@ export { defineNodeViewFactory as defineNodeViewFactory_alias_1 }
  * 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";
+Nodes: "paragraph";
+Marks: never;
+Commands: never;
 }>;
 export { defineParagraph }
 export { defineParagraph as defineParagraph_alias_1 }
@@ -509,7 +570,9 @@ export { defineParagraph as defineParagraph_alias_1 }
  * Defines a paragraph node spec.
  */
 export declare function defineParagraphSpec(): Extension<    {
-NODES: "paragraph";
+Nodes: "paragraph";
+Marks: never;
+Commands: never;
 }>;
 
 /**
@@ -517,7 +580,7 @@ NODES: "paragraph";
  *
  * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handlePaste}
  */
-declare function definePasteHandler(handler: PasteHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function definePasteHandler(handler: PasteHandler): Extension<any>;
 export { definePasteHandler }
 export { definePasteHandler as definePasteHandler_alias_1 }
 
@@ -540,7 +603,7 @@ export { definePlugin as definePlugin_alias_1 }
  *
  * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleScrollToSelection}
  */
-declare function defineScrollToSelectionHandler(handler: ScrollToSelectionHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineScrollToSelectionHandler(handler: ScrollToSelectionHandler): Extension<any>;
 export { defineScrollToSelectionHandler }
 export { defineScrollToSelectionHandler as defineScrollToSelectionHandler_alias_1 }
 
@@ -548,7 +611,9 @@ export { defineScrollToSelectionHandler as defineScrollToSelectionHandler_alias_
  * @public
  */
 declare function defineText(): Extension<    {
-NODES: "text";
+Nodes: "text";
+Marks: never;
+Commands: never;
 }>;
 export { defineText }
 export { defineText as defineText_alias_1 }
@@ -558,7 +623,7 @@ export { defineText as defineText_alias_1 }
  *
  * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleTextInput}
  */
-declare function defineTextInputHandler(handler: TextInputHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineTextInputHandler(handler: TextInputHandler): Extension<any>;
 export { defineTextInputHandler }
 export { defineTextInputHandler as defineTextInputHandler_alias_1 }
 
@@ -567,7 +632,7 @@ export { defineTextInputHandler as defineTextInputHandler_alias_1 }
  *
  * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleTripleClick}
  */
-declare function defineTripleClickHandler(handler: TripleClickHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineTripleClickHandler(handler: TripleClickHandler): Extension<any>;
 export { defineTripleClickHandler }
 export { defineTripleClickHandler as defineTripleClickHandler_alias_1 }
 
@@ -576,7 +641,7 @@ export { defineTripleClickHandler as defineTripleClickHandler_alias_1 }
  *
  * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleTripleClickOn}
  */
-declare function defineTripleClickOnHandler(handler: TripleClickOnHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineTripleClickOnHandler(handler: TripleClickOnHandler): Extension<any>;
 export { defineTripleClickOnHandler }
 export { defineTripleClickOnHandler as defineTripleClickOnHandler_alias_1 }
 
@@ -585,7 +650,7 @@ export { defineTripleClickOnHandler as defineTripleClickOnHandler_alias_1 }
  *
  * @public
  */
-declare function defineUnmountHandler(handler: UnmountHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineUnmountHandler(handler: UnmountHandler): Extension<any>;
 export { defineUnmountHandler }
 export { defineUnmountHandler as defineUnmountHandler_alias_1 }
 
@@ -594,7 +659,7 @@ export { defineUnmountHandler as defineUnmountHandler_alias_1 }
  *
  * @public
  */
-declare function defineUpdateHandler(handler: UpdateHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineUpdateHandler(handler: UpdateHandler): Extension<any>;
 export { defineUpdateHandler }
 export { defineUpdateHandler as defineUpdateHandler_alias_1 }
 
@@ -788,10 +853,6 @@ declare function elementFromNode(node: ProseMirrorNode, options?: DOMSerializerO
 export { elementFromNode }
 export { elementFromNode as elementFromNode_alias_1 }
 
-declare type EmptyValue = undefined | null | EmptyObject;
-
-export declare type ExceptEmptyValue<T> = ConditionalExcept<T, EmptyValue>;
-
 /**
  * Expands the selection to include the entire mark at the current position.
  *
@@ -809,7 +870,7 @@ export { expandMark as expandMark_alias_1 }
 /**
  * @public
  */
-declare interface Extension<T extends ExtensionTyping = ExtensionTyping> {
+declare interface Extension<T extends ExtensionTyping<any, any, any> = any> {
     extension: Extension | Extension[];
     priority?: Priority;
     _type?: T;
@@ -826,10 +887,10 @@ 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;
+declare interface ExtensionTyping<N extends string | never = never, M extends string | never = never, C extends CommandTyping | never = never> {
+    Nodes: N;
+    Marks: M;
+    Commands: C;
 }
 export { ExtensionTyping }
 export { ExtensionTyping as ExtensionTyping_alias_1 }
@@ -837,56 +898,47 @@ export { ExtensionTyping as ExtensionTyping_alias_1 }
 /**
  * @public
  */
-declare type ExtractCommandAppliers<E extends Extension> = ToCommandApplier<ExtractCommandArgs<E>>;
+declare type ExtractCommandAppliers<E extends Extension> = ToCommandApplier<ExtractCommands<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>>;
+declare type ExtractCommandCreators<E extends Extension> = ToCommandCreators<ExtractCommands<E>>;
 export { ExtractCommandCreators }
 export { ExtractCommandCreators as ExtractCommandCreators_alias_1 }
 
 /**
- * @intneral
+ * @internal
  */
-export declare type ExtractKey<T, K extends string> = Extract<T, Record<K, any>>[K];
+export declare type ExtractCommands<E extends Extension> = SimplifyUnion<ExtractTyping<E>['Commands']>;
 
 /**
  * @public
  */
-declare type ExtractMarks<E extends Extension> = ExtractMarksFromTyping<ExtractTyping<E>>;
+declare type ExtractMarks<E extends Extension> = ExtractTyping<E>['Marks'];
 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>>;
+declare type ExtractNodes<E extends Extension> = ExtractTyping<E>['Nodes'];
 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
+ * @internal
  */
 declare class Facet<Input, Output> {
+    private _reducer?;
+    private _reduce?;
     /**
      * @internal
      */
@@ -894,61 +946,61 @@ declare class Facet<Input, Output> {
     /**
      * @internal
      */
-    readonly converter: () => FacetConverter<Input, Output>;
-    /**
-     * @internal
-     */
-    readonly next: Facet<Output, any> | null;
+    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
      */
-    isSchema: boolean;
-    private constructor();
-    static define<Input, Output>({ converter, convert, next, singleton, }: FacetOptions<Input, Output>): Facet<Input, Output>;
+    readonly path: number[];
     /**
      * @internal
      */
-    static defineRootFacet<Input>(options: Omit<FacetOptions<Input, Input>, 'next'>): Facet<Input, Input>;
-    extension(payloads: Input[]): Extension;
+    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 }
 
 /**
- * @public
- */
-export declare interface FacetConverter<Input = any, Output = any> {
-    create: (inputs: Input[]) => Output;
-    update: (inputs: Input[]) => Output | null;
-}
-
-/**
- * @public
+ * @internal
  */
 export declare class FacetExtensionImpl<Input, Output> extends BaseExtension {
     readonly facet: Facet<Input, Output>;
     readonly payloads: Input[];
     extension: Extension;
-    hasSchema: boolean;
-    schema: null;
+    /**
+     * @internal
+     */
     constructor(facet: Facet<Input, Output>, payloads: Input[]);
+    /**
+     * @internal
+     */
+    createTree(priority: Priority): FacetNode<any, any>;
+}
+
+export declare class FacetNode<I = any, O = any> {
+    readonly facet: Facet<I, O>;
+    readonly inputs: Tuple5<I[] | null>;
+    readonly children: Map<number, FacetNode>;
+    reducers: Tuple5<FacetReducer<I, O> | null>;
+    output: Tuple5<O | null> | null;
+    constructor(facet: Facet<I, O>, inputs?: Tuple5<I[] | null>, children?: Map<number, FacetNode>);
+    private calcOutput;
+    getOutput(): Tuple5<O | null>;
+    getSingletonOutput(): O | null;
+    getRootOutput(): RootOutput;
+    isRoot(): boolean;
 }
 
 /**
- * @public
+ * @internal
  */
-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 type FacetReducer<Input, Output> = (input: Input[]) => Output;
 
 export declare function findBrowserDocument(options?: {
     document?: Document;
@@ -979,8 +1031,6 @@ export declare function getBrowserWindow(options?: {
 
 export declare function getCustomSelection(state: EditorState, from?: number | null, to?: number | null): Selection_3;
 
-export declare function getFacetCount(): number;
-
 /**
  * Returns a unique id in the current process that can be used in various places.
  *
@@ -1004,6 +1054,11 @@ 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[];
+
 export declare type GroupedEntries<T extends Record<string, any>> = {
     [K in keyof T]?: T[K][];
 };
@@ -1296,8 +1351,19 @@ declare interface NodeAttrOptions {
      * of a type that has them is created.
      */
     default?: any;
+    /**
+     * 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 DOM node.
+     *
+     * If the `key` is `"style"`, the value is a string of CSS properties and will
+     * be prepended to the existing `style` attribute on the DOM node.
      */
     toDOM?: (value: any) => [key: string, value: string] | null | void;
     /**
@@ -1420,11 +1486,10 @@ declare type PasteHandler = (view: EditorView, event: ClipboardEvent, slice: Sli
 export { PasteHandler }
 export { PasteHandler as PasteHandler_alias_1 }
 
-declare type Payload = unknown;
-
-export declare type Payloads = PayloadTuple[];
-
-declare type PayloadTuple = Tuple5<Payload[]>;
+/**
+ * @internal
+ */
+export declare type Payloads<T> = Tuple5<T[]>;
 
 /**
  * @internal
@@ -1436,9 +1501,9 @@ export { pluginFacet as pluginFacet_alias_1 }
 /**
  * @internal
  */
-declare type PluginPayload = (context: {
+declare type PluginPayload = Plugin_2 | Plugin_2[] | ((context: {
     schema: Schema;
-}) => Plugin_2 | Plugin_2[];
+}) => Plugin_2 | Plugin_2[]);
 export { PluginPayload }
 export { PluginPayload as PluginPayload_alias_1 }
 
@@ -1448,11 +1513,11 @@ export { PluginPayload as PluginPayload_alias_1 }
  * @public
  */
 declare enum Priority {
-    lowest = 4,
-    low = 3,
+    lowest = 0,
+    low = 1,
     default = 2,
-    high = 1,
-    highest = 0
+    high = 3,
+    highest = 4
 }
 export { Priority }
 export { Priority as Priority_alias_1 }
@@ -1493,9 +1558,27 @@ declare function removeMark(options: {
 export { removeMark }
 export { removeMark as removeMark_alias_1 }
 
-export declare const schemaFacet: Facet<SchemaPayload, SchemaPayload>;
+export declare const rootFacet: Facet<RootPayload, RootOutput>;
 
-export declare type SchemaPayload = SchemaSpec;
+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<any, any>, RootPayload>;
+
+export declare const schemaSpecFacet: Facet<SchemaSpec<any, any>, SchemaSpec<any, any>>;
 
 declare type ScrollToSelectionHandler = (view: EditorView) => boolean;
 export { ScrollToSelectionHandler }
@@ -1547,7 +1630,7 @@ declare function setNodeAttrs(options: {
      *
      * If current node is not of this type, the command will do nothing.
      */
-    type: string | NodeType;
+    type: string | NodeType | string[] | NodeType[];
     /**
      * The attributes to set.
      */
@@ -1568,17 +1651,6 @@ export declare function setSelectionAround(tr: Transaction, pos: number): void;
  */
 export declare type Setter<T> = (value: T) => void;
 
-/**
- * @internal
- */
-declare type SimplifyExtension<E extends Extension | Extension[]> = E extends Extension[] ? Extension<ExceptEmptyValue<{
-    NODES: ExtractNodes<E[number]>;
-    MARKS: ExtractMarks<E[number]>;
-    COMMAND_ARGS: SimplifyUnion<ExtractCommandArgs<E[number]>>;
-}>> : E;
-export { SimplifyExtension }
-export { SimplifyExtension as SimplifyExtension_alias_1 }
-
 /**
  * @intneral
  */
@@ -1586,7 +1658,7 @@ declare type SimplifyUnion<T> = Simplify<UnionToIntersection<T>>;
 export { SimplifyUnion }
 export { SimplifyUnion as SimplifyUnion_alias_1 }
 
-export declare const stateFacet: Facet<StatePayload, StatePayload>;
+export declare const stateFacet: Facet<StatePayload, RootPayload>;
 
 /**
  * Parse a JSON object to a ProseMirror state.
@@ -1619,19 +1691,17 @@ export declare type StatePayload = (ctx: {
     schema: Schema;
 }) => EditorStateConfig;
 
+export declare function subtractFacetNode<I, O>(a: FacetNode<I, O>, b: FacetNode<I, O>): FacetNode<I, O>;
+
 declare type TextInputHandler = (view: EditorView, from: number, to: number, text: string) => boolean | void;
 export { TextInputHandler }
 export { TextInputHandler as TextInputHandler_alias_1 }
 
-export declare type ToCommandApplier<T extends CommandArgs> = {
+export declare type ToCommandApplier<T extends CommandTyping> = {
     [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> = {
+export declare type ToCommandCreators<T extends CommandTyping> = {
     [K in keyof T]: CommandCreator<T[K]>;
 };
 
@@ -1660,6 +1730,8 @@ declare function toggleNode({ type, attrs, }: {
 export { toggleNode }
 export { toggleNode as toggleNode_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 }
@@ -1668,26 +1740,45 @@ declare type TripleClickOnHandler = (view: EditorView, pos: number, node: Node_3
 export { TripleClickOnHandler }
 export { TripleClickOnHandler as TripleClickOnHandler_alias_1 }
 
-declare type Tuple5<T> = [T, T, T, T, T];
+/**
+ * @internal
+ */
+export declare type Tuple5<T> = [T, T, T, T, T];
 
 /**
  * Merge multiple extensions into one.
  *
  * @public
  */
-declare function union<E extends Extension | Extension[]>(extension: E): SimplifyExtension<E>;
+declare function union<E extends Extension | Extension[]>(extension: E): UnionExtension<E>;
 export { union }
 export { union as union_alias_1 }
 
+/**
+ * @internal
+ */
+declare type UnionExtension<E extends Extension | Extension[]> = E extends 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[];
-    private _schema;
-    private hasSchemaCount;
+    /**
+     * @internal
+     */
     constructor(extension?: BaseExtension[]);
-    get hasSchema(): boolean;
-    get schema(): Schema | null;
+    /**
+     * @internal
+     */
+    createTree(priority: Priority): FacetNode;
 }
 
+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[];
@@ -1701,13 +1792,6 @@ declare type UnmountHandler = () => void;
 export { UnmountHandler }
 export { UnmountHandler as UnmountHandler_alias_1 }
 
-export declare function updateExtension(prevInputs: Payloads, prevConverters: Converters, extension: Extension, mode: 'add' | 'remove'): {
-    schemaInput: SchemaPayload | null;
-    stateInput: StatePayload | null;
-    viewInput: ViewPayload | null;
-    commandInput: CommandCreators | null;
-};
-
 /**
  * A function that is called when the editor state is updated.
  *
@@ -1720,7 +1804,7 @@ declare type UpdateHandler = (view: EditorView, prevState: EditorState) => void;
 export { UpdateHandler }
 export { UpdateHandler as UpdateHandler_alias_1 }
 
-export declare const viewFacet: Facet<ViewPayload, ViewPayload>;
+export declare const viewFacet: Facet<ViewPayload, RootPayload>;
 
 export declare type ViewPayload = Omit<DirectEditorProps, 'state'>;
 
@@ -1751,4 +1835,6 @@ export declare function wrap({ nodeType, attrs, }: {
     attrs?: Attrs | null;
 }): Command;
 
+export declare function zip<T, P>(a: T[], b: P[]): [T, P][];
+
 export { }