@prosekit/core 0.7.3 → 0.7.5

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

@@ -1,5 +1,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 { ContentMatch } from '@prosekit/pm/model';
 import { config as default_alias_1 } from '@prosekit/dev/config-vitest';
@@ -19,8 +20,8 @@ import { NodeSelection } from '@prosekit/pm/state';
 import type { NodeSpec } from '@prosekit/pm/model';
 import { NodeType } from '@prosekit/pm/model';
 import { NodeType as NodeType_2 } from 'prosemirror-model';
-import { NodeView } from '@prosekit/pm/view';
-import { NodeViewConstructor } from '@prosekit/pm/view';
+import type { NodeView } from '@prosekit/pm/view';
+import type { NodeViewConstructor } from '@prosekit/pm/view';
 import { Options } from 'tsup';
 import type { ParseOptions } from '@prosekit/pm/model';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
@@ -75,6 +76,15 @@ declare interface AddMarkOptions {
 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 }
+
 export declare function applyAction(operator: Action): Command;
 
 export declare const applyMarkForTest: ApplyMarkFunction;
@@ -106,8 +116,38 @@ export { assert as assert_alias_1 }
  */
 export declare function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void;
 
+/**
+ * Utility function assert that two types are equal in tests.
+ */
+export declare function assertTypeEqual_alias_1<T, U>(_val: IsEqual<T, U>): void;
+
 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
  */
@@ -199,10 +239,19 @@ export { collectNodes as collectNodes_alias_1 }
 
 export declare function combineEventHandlers<Handler extends (...args: any[]) => boolean | void, Args extends Parameters<Handler> = Parameters<Handler>>(): readonly [(handlers: Handler[]) => void, (...args: Args) => boolean];
 
-export declare interface CommandApplier<Args extends any[] = any[]> {
+/**
+ * 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 `canApply` method to check if the command can be applied.
+ *
+ * @public
+ */
+declare interface CommandAction<Args extends any[] = any[]> {
     (...args: Args): boolean;
     canApply(...args: Args): boolean;
 }
+export { CommandAction }
+export { CommandAction as CommandAction_alias_1 }
 
 export declare type CommandCreator<Args extends any[] = any[]> = (...arg: Args) => Command;
 
@@ -223,6 +272,13 @@ declare interface CommandTyping {
 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
  */
@@ -233,12 +289,12 @@ export { createEditor as createEditor_alias_1 }
 /**
  * @internal
  */
-export declare function createMarkBuilders(schema: Schema, getState: () => EditorState | null | undefined, applyMark?: ApplyMarkFunction): Record<string, MarkBuilder>;
+export declare function createMarkActions(schema: Schema, getState: () => EditorState | null | undefined, applyMark?: ApplyMarkFunction): Record<string, MarkAction>;
 
 /**
  * @internal
  */
-export declare function createNodeBuilders(schema: Schema, getState: () => EditorState | null | undefined, createNode?: CreateNodeFunction): Record<string, NodeBuilder>;
+export declare function createNodeActions(schema: Schema, getState: () => EditorState | null | undefined, createNode?: CreateNodeFunction): Record<string, NodeAction>;
 
 export declare const createNodeForTest: CreateNodeFunction;
 
@@ -368,7 +424,9 @@ export { defineDefaultState as defineDefaultState_alias_1 }
  * @public
  */
 declare function defineDoc(): Extension<    {
-Nodes: "doc";
+Nodes: {
+doc: Attrs_2;
+};
 Marks: never;
 Commands: never;
 }>;
@@ -507,15 +565,23 @@ export { defineKeyPressHandler as defineKeyPressHandler_alias_1 }
 /**
  * @public
  */
-declare function defineMarkAttr(options: MarkAttrOptions): Extension;
+declare function defineMarkAttr<MarkType extends string = string, AttrName extends string = string, AttrType = any>(options: MarkAttrOptions<MarkType, AttrName, AttrType>): Extension<{
+    Nodes: never;
+    Marks: {
+        [K in MarkType]: AttrType;
+    };
+    Commands: never;
+}>;
 export { defineMarkAttr }
 export { defineMarkAttr as defineMarkAttr_alias_1 }
 
 /**
  * @public
  */
-declare function defineMarkSpec<Mark extends string>(options: MarkSpecOptions<Mark>): Extension<{
-    Marks: Mark;
+declare function defineMarkSpec<Mark extends string, Attrs extends AnyAttrs = AnyAttrs>(options: MarkSpecOptions<Mark, Attrs>): Extension<{
+    Marks: {
+        [K in Mark]: Attrs;
+    };
     Nodes: never;
     Commands: never;
 }>;
@@ -536,7 +602,15 @@ export { defineMountHandler as defineMountHandler_alias_1 }
  *
  * @public
  */
-declare function defineNodeAttr(options: NodeAttrOptions): Extension;
+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;
+        };
+    };
+    Marks: never;
+    Commands: never;
+}>;
 export { defineNodeAttr }
 export { defineNodeAttr as defineNodeAttr_alias_1 }
 
@@ -545,8 +619,10 @@ export { defineNodeAttr as defineNodeAttr_alias_1 }
  *
  * @public
  */
-declare function defineNodeSpec<Node extends string>(options: NodeSpecOptions<Node>): Extension<{
-    Nodes: Node;
+declare function defineNodeSpec<Node extends string, Attrs extends AnyAttrs = AnyAttrs>(options: NodeSpecOptions<Node, Attrs>): Extension<{
+    Nodes: {
+        [K in Node]: Attrs;
+    };
     Marks: never;
     Commands: never;
 }>;
@@ -577,7 +653,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: Attrs_2;
+};
 Marks: never;
 Commands: never;
 }>;
@@ -590,7 +668,9 @@ export { defineParagraph as defineParagraph_alias_1 }
  * Defines a paragraph node spec.
  */
 export declare function defineParagraphSpec(): Extension<    {
-Nodes: "paragraph";
+Nodes: {
+paragraph: Attrs_2;
+};
 Marks: never;
 Commands: never;
 }>;
@@ -631,8 +711,19 @@ export { defineScrollToSelectionHandler as defineScrollToSelectionHandler_alias_
  * @internal
  */
 export declare function defineTestExtension(): Extension<{
-    Nodes: "text" | "doc" | "paragraph" | "heading";
-    Marks: "bold" | "italic";
+    Nodes: SimplifyDeeper<    {
+    paragraph: Attrs_2;
+    doc: Attrs_2;
+    text: Attrs_2;
+    heading: Attrs_2;
+    codeBlock: {
+    language: string;
+    };
+    }>;
+    Marks: SimplifyDeeper<    {
+    bold: Attrs_2;
+    italic: Attrs_2;
+    }>;
     Commands: {
         insertText: [{
             text: string;
@@ -658,7 +749,9 @@ export declare function defineTestExtension(): Extension<{
  * @public
  */
 declare function defineText(): Extension<    {
-Nodes: "text";
+Nodes: {
+text: Attrs_2;
+};
 Marks: never;
 Commands: never;
 }>;
@@ -811,11 +904,7 @@ declare class Editor<E extends Extension = any> {
     /**
      * The editor schema.
      */
-    get schema(): Schema<ExtractNodes<E>, ExtractMarks<E>>;
-    /**
-     * All commands defined by the editor.
-     */
-    get commands(): ExtractCommandAppliers<E>;
+    get schema(): Schema<ExtractNodeNames<E>, ExtractMarkNames<E>>;
     /**
      * Whether the editor is focused.
      */
@@ -855,8 +944,18 @@ declare class Editor<E extends Extension = any> {
      * directly manipulate the editor's state.
      */
     updateState(state: EditorState): void;
-    get nodes(): Record<ExtractNodes<E>, NodeBuilder>;
-    get marks(): Record<ExtractMarks<E>, MarkBuilder>;
+    /**
+     * 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 }
@@ -867,9 +966,9 @@ export { Editor as Editor_alias_1 }
 export declare class EditorInstance {
     view: EditorView | null;
     schema: Schema;
-    nodeBuilders: Record<string, NodeBuilder>;
-    markBuilders: Record<string, MarkBuilder>;
-    commandAppliers: Record<string, CommandApplier>;
+    nodes: Record<string, NodeAction>;
+    marks: Record<string, MarkAction>;
+    commands: Record<string, CommandAction>;
     private tree;
     private directEditorProps;
     constructor(extension: Extension);
@@ -988,7 +1087,7 @@ export { Extension as Extension_alias_1 }
 /**
  * @internal
  */
-declare interface ExtensionTyping<N extends string | never = never, M extends string | never = never, C extends CommandTyping | never = never> {
+declare interface ExtensionTyping<N extends NodeTyping | never = never, M extends MarkTyping | never = never, C extends CommandTyping | never = never> {
     Nodes: N;
     Marks: M;
     Commands: C;
@@ -997,9 +1096,18 @@ export { ExtensionTyping }
 export { ExtensionTyping as ExtensionTyping_alias_1 }
 
 /**
+ * Extracts the {@link CommandAction}s from an extension type.
+ *
  * @public
  */
-declare type ExtractCommandAppliers<E extends Extension> = ToCommandApplier<ExtractCommands<E>>;
+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 }
 
@@ -1015,17 +1123,45 @@ export { ExtractCommandCreators as ExtractCommandCreators_alias_1 }
  */
 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> = ExtractTyping<E>['Marks'];
+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> = ExtractTyping<E>['Nodes'];
+declare type ExtractNodes<E extends Extension> = SimplifyDeeper<SimplifyUnion<ExtractTyping<E>['Nodes']>>;
 export { ExtractNodes }
 export { ExtractNodes as ExtractNodes_alias_1 }
 
@@ -1034,7 +1170,7 @@ export declare function extractTags(node: TaggedProseMirrorNode): Record<string,
 /**
  * @internal
  */
-export declare type ExtractTyping<E extends Extension> = E extends Extension<ExtensionTyping<infer N, infer M, infer C>> ? ExtensionTyping<PickStringLiteral<N>, PickStringLiteral<M>, PickKnownCommandTyping<C>> : never;
+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
@@ -1220,6 +1356,8 @@ declare function htmlFromNode(node: ProseMirrorNode, options?: DOMSerializerOpti
 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 the given node at the current selection or at
  * the given position.
@@ -1315,6 +1453,7 @@ 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
  */
@@ -1347,6 +1486,13 @@ declare function isProseMirrorNode(node: unknown): node is ProseMirrorNode;
 export { isProseMirrorNode }
 export { isProseMirrorNode as isProseMirrorNode_alias_1 }
 
+/**
+ * Check if `subset` is a subset of `superset`.
+ *
+ * @internal
+ */
+export declare function isSubset(subset: Record<string, unknown>, superset: Record<string, unknown>): boolean;
+
 /**
  * @internal
  */
@@ -1427,23 +1573,39 @@ 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 MarkAttrOptions {
+declare interface MarkAction<Attrs extends AnyAttrs = AnyAttrs> {
+    (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode[];
+    (...children: NodeChild[]): ProseMirrorNode[];
     /**
-     * The name of the mark type.
+     * 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.
      */
-    type: string;
+    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 attribute.
+     * The name of the mark type.
      */
-    attr: string;
+    type: MarkName;
     /**
-     * The default value for this attribute, to use when no explicit value is
-     * provided. Attributes that have no default must be provided whenever a mark
-     * of a type that has them is created.
+     * The name of the attribute.
      */
-    default?: any;
+    attr: AttrName;
     /**
      * Returns the attribute key and value to be set on the DOM node.
      */
@@ -1457,25 +1619,39 @@ export { MarkAttrOptions }
 export { MarkAttrOptions as MarkAttrOptions_alias_1 }
 
 /**
- * @public
+ * @deprecated Use type {@link MarkAction} instead.
  */
-declare interface MarkBuilder {
-    (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode[];
-    (...children: NodeChild[]): ProseMirrorNode[];
-    isActive: (attrs?: Attrs) => boolean;
-}
+declare type MarkBuilder = MarkAction;
 export { MarkBuilder }
 export { MarkBuilder as MarkBuilder_alias_1 }
 
 /**
  * @public
  */
-declare interface MarkSpecOptions<MarkName extends string = string> extends MarkSpec {
+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
  */
@@ -1495,23 +1671,39 @@ 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 NodeAttrOptions {
+declare interface NodeAction<Attrs extends AnyAttrs = AnyAttrs> {
+    (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode;
+    (...children: NodeChild[]): ProseMirrorNode;
     /**
-     * The name of the node type.
+     * 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.
      */
-    type: string;
+    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 attribute.
+     * The name of the node type.
      */
-    attr: string;
+    type: NodeName;
     /**
-     * The default value for this attribute, to use when no explicit value is
-     * provided. Attributes that have no default must be provided whenever a node
-     * of a type that has them is created.
+     * The name of the attribute.
      */
-    default?: any;
+    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
@@ -1536,20 +1728,20 @@ export { NodeAttrOptions }
 export { NodeAttrOptions as NodeAttrOptions_alias_1 }
 
 /**
- * @public
+ * @deprecated Use type {@link NodeAction} instead.
  */
-declare interface NodeBuilder {
-    (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode;
-    (...children: NodeChild[]): ProseMirrorNode;
-    isActive: (attrs?: Attrs) => boolean;
-}
+declare type NodeBuilder = NodeAction;
 export { NodeBuilder }
 export { NodeBuilder as NodeBuilder_alias_1 }
 
 /**
+ * Available children parameters for {@link NodeAction} and {@link MarkAction}.
+ *
  * @public
  */
-export declare type NodeChild = ProseMirrorNode | string | NodeChild[];
+declare type NodeChild = ProseMirrorNode | string | NodeChild[];
+export { NodeChild }
+export { NodeChild as NodeChild_alias_1 }
 
 /**
  * @public
@@ -1603,13 +1795,35 @@ export { NodeJSON as NodeJSON_alias_1 }
 /**
  * @public
  */
-declare interface NodeSpecOptions<NodeName extends string = string> extends NodeSpec {
+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
  */
@@ -1674,14 +1888,14 @@ export declare type Payloads<T> = Tuple5<T[]>;
 /**
  * @internal
  */
-export declare type PickKnownCommandTyping<T extends CommandTyping> = [
-CommandTyping
-] extends [T] ? never : T;
+export declare type PickStringLiteral<T> = PickSubType<T, string>;
 
 /**
  * @internal
  */
-export declare type PickStringLiteral<T extends string> = [string] extends [T] ? never : T;
+declare type PickSubType<Type, ParentType> = Type extends ParentType ? [ParentType] extends [Type] ? never : Type : never;
+export { PickSubType }
+export { PickSubType as PickSubType_alias_1 }
 
 /**
  * @internal
@@ -1899,8 +2113,19 @@ export declare function setupEditorExtension<E extends Extension>(options: Edito
  */
 export declare function setupTest(): {
     editor: TestEditor<Extension<{
-        Nodes: "text" | "doc" | "paragraph" | "heading";
-        Marks: "bold" | "italic";
+        Nodes: SimplifyDeeper<    {
+        paragraph: Attrs_2;
+        doc: Attrs_2;
+        text: Attrs_2;
+        heading: Attrs_2;
+        codeBlock: {
+        language: string;
+        };
+        }>;
+        Marks: SimplifyDeeper<    {
+        bold: Attrs_2;
+        italic: Attrs_2;
+        }>;
         Commands: {
             insertText: [{
                 text: string;
@@ -1921,8 +2146,34 @@ export declare function setupTest(): {
             readonly redo: [];
         };
     }>>;
-    n: Record<"text" | "doc" | "paragraph" | "heading", NodeBuilder>;
-    m: Record<"bold" | "italic", MarkBuilder>;
+    m: ToMarkAction<SimplifyDeeper<    {
+    bold: {
+    readonly [x: string]: any;
+    };
+    italic: {
+    readonly [x: string]: any;
+    };
+    }>>;
+    n: {
+        p: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        paragraph: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        doc: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        text: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        heading: NodeAction<    {
+        readonly [x: string]: any;
+        }>;
+        codeBlock: NodeAction<    {
+        language: string;
+        }>;
+    };
 };
 
 /**
@@ -1930,9 +2181,18 @@ export declare function setupTest(): {
  */
 export declare function setupTestFromExtension<E extends Extension>(extension: E): {
     editor: TestEditor<E>;
-    n: Record<ExtractNodes<E>, NodeBuilder>;
-    m: Record<ExtractMarks<E>, MarkBuilder>;
+    n: ExtractNodeActions<E>;
+    m: ExtractMarkActions<E>;
+};
+
+/**
+ * @internal
+ */
+declare type SimplifyDeeper<T> = {
+    [KeyType in keyof T]: Simplify<T[KeyType]>;
 };
+export { SimplifyDeeper }
+export { SimplifyDeeper as SimplifyDeeper_alias_1 }
 
 /**
  * @internal
@@ -2034,8 +2294,8 @@ declare type TextInputHandler = (view: EditorView, from: number, to: number, tex
 export { TextInputHandler }
 export { TextInputHandler as TextInputHandler_alias_1 }
 
-export declare type ToCommandApplier<T extends CommandTyping> = {
-    [K in keyof T]: CommandApplier<T[K]>;
+export declare type ToCommandAction<T extends CommandTyping> = {
+    [K in keyof T]: CommandAction<T[K]>;
 };
 
 export declare type ToCommandCreators<T extends CommandTyping> = {
@@ -2087,6 +2347,24 @@ declare interface ToggleNodeOptions {
 export { ToggleNodeOptions }
 export { ToggleNodeOptions as ToggleNodeOptions_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;

package/dist/{chunk-UDQXAK7F.js → chunk-M267LRMB.js}

@@ -512,15 +512,36 @@ function defineDefaultState({
   ]);
 }
 
+// src/utils/is-subset.ts
+function isSubset(subset, superset) {
+  return Object.keys(subset).every((key) => subset[key] === superset[key]);
+}
+
+// src/utils/includes-mark.ts
+function includesMark(marks, markType, attrs) {
+  attrs = attrs || {};
+  return marks.some((mark) => {
+    return mark.type === markType && isSubset(attrs, mark.attrs);
+  });
+}
+
 // src/utils/is-mark-absent.ts
 function isMarkAbsent(node, from, to, markType, attrs) {
-  const mark = attrs ? markType.create(attrs) : markType;
   let missing = false;
+  let available = false;
   node.nodesBetween(from, to, (node2, pos, parent) => {
-    if (missing) return false;
-    missing = !mark.isInSet(node2.marks) && !!parent && parent.type.allowsMarkType(markType);
+    if (missing) {
+      return false;
+    }
+    const allowed = (parent == null ? void 0 : parent.type.allowsMarkType(markType)) && !node2.marks.some((m) => m.type !== markType && m.type.excludes(markType));
+    if (allowed) {
+      available = true;
+      if (!includesMark(node2.marks, markType, attrs)) {
+        missing = true;
+      }
+    }
   });
-  return missing;
+  return available ? missing : true;
 }
 
 // src/utils/is-mark-active.ts
@@ -528,8 +549,8 @@ function isMarkActive(state, type, attrs) {
   const { from, $from, to, empty } = state.selection;
   const markType = getMarkType(state.schema, type);
   if (empty) {
-    const mark = attrs ? markType.create(attrs) : markType;
-    return !!mark.isInSet(state.storedMarks || $from.marks());
+    const marks = state.storedMarks || $from.marks();
+    return includesMark(marks, markType, attrs);
   } else {
     return !isMarkAbsent(state.doc, from, to, markType, attrs);
   }
@@ -625,7 +646,7 @@ function deepEquals(a, b) {
   return false;
 }
 
-// src/editor/builder.ts
+// src/editor/action.ts
 import "@prosekit/pm/model";
 
 // src/utils/attrs-match.ts
@@ -652,8 +673,8 @@ function isNodeActive(state, type, attrs) {
   return false;
 }
 
-// src/editor/builder.ts
-function createNodeBuilders(schema, getState, createNode = defaultCreateNode) {
+// src/editor/action.ts
+function createNodeActions(schema, getState, createNode = defaultCreateNode) {
   const builders = {};
   for (const type of Object.values(schema.nodes)) {
     const builder = (...args) => buildNode(type, args, createNode);
@@ -665,7 +686,7 @@ function createNodeBuilders(schema, getState, createNode = defaultCreateNode) {
   }
   return builders;
 }
-function createMarkBuilders(schema, getState, applyMark = defaultApplyMark) {
+function createMarkActions(schema, getState, applyMark = defaultApplyMark) {
   const builders = {};
   for (const type of Object.values(schema.marks)) {
     const builder = (...args) => buildMark(type, args, applyMark);
@@ -751,7 +772,7 @@ function createEditor(options) {
 var EditorInstance = class {
   constructor(extension) {
     this.view = null;
-    this.commandAppliers = {};
+    this.commands = {};
     this.getState = () => {
       var _a;
       return ((_a = this.view) == null ? void 0 : _a.state) || this.directEditorProps.state;
@@ -767,8 +788,8 @@ var EditorInstance = class {
         this.defineCommand(name, commandCreator);
       }
     }
-    this.nodeBuilders = createNodeBuilders(state.schema, this.getState);
-    this.markBuilders = createMarkBuilders(state.schema, this.getState);
+    this.nodes = createNodeActions(state.schema, this.getState);
+    this.marks = createMarkActions(state.schema, this.getState);
     this.schema = state.schema;
     this.directEditorProps = { state, ...payload.view };
   }
@@ -852,13 +873,13 @@ var EditorInstance = class {
     view.setProps({ state: newState });
   }
   defineCommand(name, commandCreator) {
-    const applier = (...args) => {
+    const action = (...args) => {
       const view = this.view;
       assert(view, `Cannot call command "${name}" before the editor is mounted`);
       const command = commandCreator(...args);
       return command(view.state, view.dispatch.bind(view), view);
     };
-    applier.canApply = (...args) => {
+    action.canApply = (...args) => {
       const view = this.view;
       if (!view) {
         return false;
@@ -866,10 +887,10 @@ var EditorInstance = class {
       const command = commandCreator(...args);
       return command(view.state, void 0, view);
     };
-    this.commandAppliers[name] = applier;
+    this.commands[name] = action;
   }
   removeCommand(name) {
-    delete this.commandAppliers[name];
+    delete this.commands[name];
   }
 };
 var Editor = class _Editor {
@@ -910,12 +931,6 @@ var Editor = class _Editor {
   get schema() {
     return this.instance.schema;
   }
-  /**
-   * All commands defined by the editor.
-   */
-  get commands() {
-    return this.instance.commandAppliers;
-  }
   /**
    * Whether the editor is focused.
    */
@@ -995,11 +1010,23 @@ var Editor = class _Editor {
   updateState(state) {
     this.instance.updateState(state);
   }
+  /**
+   * All {@link CommandAction}s defined by the editor.
+   */
+  get commands() {
+    return this.instance.commands;
+  }
+  /**
+   * All {@link NodeAction}s defined by the editor.
+   */
   get nodes() {
-    return this.instance.nodeBuilders;
+    return this.instance.nodes;
   }
+  /**
+   * All {@link MarkAction}s defined by the editor.
+   */
   get marks() {
-    return this.instance.markBuilders;
+    return this.instance.marks;
   }
 };
 
@@ -1037,8 +1064,8 @@ export {
   isTextSelection,
   isNodeSelection,
   isAllSelection,
-  createNodeBuilders,
-  createMarkBuilders,
+  createNodeActions,
+  createMarkActions,
   union,
   setupEditorExtension,
   createEditor,

package/dist/prosekit-core-test.js

@@ -2,10 +2,10 @@ import {
   Editor,
   EditorInstance,
   assert,
-  createMarkBuilders,
-  createNodeBuilders,
+  createMarkActions,
+  createNodeActions,
   setupEditorExtension
-} from "./chunk-UDQXAK7F.js";
+} from "./chunk-M267LRMB.js";
 
 // src/test/test-editor.ts
 import { EditorState, NodeSelection, TextSelection } from "@prosekit/pm/state";
@@ -82,16 +82,8 @@ function getSelection(doc) {
 var TestEditorInstance = class extends EditorInstance {
   constructor(extension) {
     super(extension);
-    this.nodeBuilders = createNodeBuilders(
-      this.schema,
-      this.getState,
-      createNodeForTest
-    );
-    this.markBuilders = createMarkBuilders(
-      this.schema,
-      this.getState,
-      applyMarkForTest
-    );
+    this.nodes = createNodeActions(this.schema, this.getState, createNodeForTest);
+    this.marks = createMarkActions(this.schema, this.getState, applyMarkForTest);
   }
 };
 var TestEditor = class extends Editor {

package/dist/prosekit-core.d.ts

@@ -22,8 +22,11 @@ export { unsetMark } from './_tsup-dts-rollup';
 export { UnsetMarkOptions } from './_tsup-dts-rollup';
 export { wrap } from './_tsup-dts-rollup';
 export { WrapOptions } from './_tsup-dts-rollup';
+export { MarkAction } from './_tsup-dts-rollup';
 export { MarkBuilder } from './_tsup-dts-rollup';
+export { NodeAction } from './_tsup-dts-rollup';
 export { NodeBuilder } from './_tsup-dts-rollup';
+export { NodeChild } from './_tsup-dts-rollup';
 export { Editor } from './_tsup-dts-rollup';
 export { createEditor } from './_tsup-dts-rollup';
 export { EditorOptions } from './_tsup-dts-rollup';
@@ -101,26 +104,39 @@ export { defineText } from './_tsup-dts-rollup';
 export { defineFacet } from './_tsup-dts-rollup';
 export { Facet } from './_tsup-dts-rollup';
 export { defineFacetPayload } from './_tsup-dts-rollup';
+export { AnyAttrs } from './_tsup-dts-rollup';
+export { AttrSpec } from './_tsup-dts-rollup';
 export { BaseNodeViewOptions } from './_tsup-dts-rollup';
-export { CommandTyping } from './_tsup-dts-rollup';
 export { Extension } from './_tsup-dts-rollup';
 export { ExtensionTyping } from './_tsup-dts-rollup';
+export { ExtractCommandActions } from './_tsup-dts-rollup';
 export { ExtractCommandAppliers } from './_tsup-dts-rollup';
 export { ExtractCommandCreators } from './_tsup-dts-rollup';
+export { ExtractMarkActions } from './_tsup-dts-rollup';
 export { ExtractMarks } from './_tsup-dts-rollup';
+export { ExtractNodeActions } from './_tsup-dts-rollup';
 export { ExtractNodes } from './_tsup-dts-rollup';
 export { UnionExtension } from './_tsup-dts-rollup';
+export { CommandAction } from './_tsup-dts-rollup';
+export { CommandTyping } from './_tsup-dts-rollup';
+export { MarkTyping } from './_tsup-dts-rollup';
+export { ToMarkAction } from './_tsup-dts-rollup';
+export { NodeTyping } from './_tsup-dts-rollup';
+export { ToNodeAction } from './_tsup-dts-rollup';
 export { NodeJSON } from './_tsup-dts-rollup';
 export { SelectionJSON } from './_tsup-dts-rollup';
 export { StateJSON } from './_tsup-dts-rollup';
 export { StepJSON } from './_tsup-dts-rollup';
+export { PickSubType } from './_tsup-dts-rollup';
 export { Priority } from './_tsup-dts-rollup';
+export { SimplifyDeeper } from './_tsup-dts-rollup';
 export { SimplifyUnion } from './_tsup-dts-rollup';
 export { assert } from './_tsup-dts-rollup';
 export { canUseRegexLookbehind } from './_tsup-dts-rollup';
 export { clsx } from './_tsup-dts-rollup';
 export { collectNodes } from './_tsup-dts-rollup';
 export { NodeContent } from './_tsup-dts-rollup';
+export { containsInlineNode } from './_tsup-dts-rollup';
 export { defaultBlockAt } from './_tsup-dts-rollup';
 export { isApple } from './_tsup-dts-rollup';
 export { _getId } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -35,11 +35,10 @@ import {
   stateFromJSON,
   toReversed,
   union
-} from "./chunk-UDQXAK7F.js";
+} from "./chunk-M267LRMB.js";
 
 // src/commands/add-mark.ts
 import "@prosekit/pm/model";
-import "@prosekit/pm/state";
 function addMark(options) {
   return (state, dispatch) => {
     var _a, _b;
@@ -108,7 +107,6 @@ function expandMarkAfter($pos, predicate) {
 }
 
 // src/commands/insert-node.ts
-import "@prosekit/pm/state";
 import { insertPoint } from "@prosekit/pm/transform";
 
 // src/utils/set-selection-around.ts
@@ -143,7 +141,6 @@ function insertNode(options) {
 
 // src/commands/remove-mark.ts
 import "@prosekit/pm/model";
-import "@prosekit/pm/state";
 function removeMark(options) {
   return (state, dispatch) => {
     var _a, _b;
@@ -192,9 +189,6 @@ function removeNode(options) {
   };
 }
 
-// src/commands/set-block-type.ts
-import "@prosekit/pm/state";
-
 // src/utils/get-custom-selection.ts
 import { TextSelection as TextSelection3 } from "@prosekit/pm/state";
 function getCustomSelection(state, from, to) {
@@ -366,7 +360,6 @@ function toggleMark({ type, attrs }) {
 // src/commands/toggle-node.ts
 import { setBlockType as setBlockType2 } from "@prosekit/pm/commands";
 import "@prosekit/pm/model";
-import "@prosekit/pm/state";
 function toggleNode({ type, attrs }) {
   return (state, dispatch, view) => {
     if (isNodeActive(state, type, attrs)) {
@@ -426,7 +419,6 @@ function unsetTextBlockType(tr, from, to) {
 }
 
 // src/commands/unset-mark.ts
-import "@prosekit/pm/state";
 function unsetMark(options) {
   return (state, dispatch) => {
     var _a, _b;
@@ -440,7 +432,6 @@ function unsetMark(options) {
 
 // src/commands/wrap.ts
 import "@prosekit/pm/model";
-import "@prosekit/pm/state";
 import { findWrapping } from "@prosekit/pm/transform";
 function wrap({ nodeType, attrs }) {
   return (state, dispatch) => {
@@ -1163,7 +1154,6 @@ var markSpecFacet = defineFacet({
 
 // src/extensions/node-view.ts
 import { PluginKey as PluginKey5, ProseMirrorPlugin as ProseMirrorPlugin5 } from "@prosekit/pm/state";
-import "@prosekit/pm/view";
 function defineNodeView(options) {
   return defineFacetPayload(nodeViewFacet, [options]);
 }
@@ -1187,7 +1177,6 @@ var nodeViewFacet = defineFacet({
 
 // src/extensions/node-view-effect.ts
 import { PluginKey as PluginKey6, ProseMirrorPlugin as ProseMirrorPlugin6 } from "@prosekit/pm/state";
-import "@prosekit/pm/view";
 function defineNodeViewFactory(options) {
   const input = [options, null];
   return defineFacetPayload(nodeViewFactoryFacet, [input]);
@@ -1285,6 +1274,16 @@ function collectNodes(content) {
   throw new ProseKitError(`Invalid node content: ${typeof content}`);
 }
 
+// src/utils/contains-inline-node.ts
+function containsInlineNode(doc, from, to) {
+  let found = false;
+  doc.nodesBetween(from, to, (node) => {
+    if (found) return false;
+    if (node.isInline) found = true;
+  });
+  return found;
+}
+
 // src/utils/default-block-at.ts
 function defaultBlockAt(match) {
   for (let i = 0; i < match.edgeCount; i++) {
@@ -1346,6 +1345,7 @@ export {
   canUseRegexLookbehind,
   clsx,
   collectNodes,
+  containsInlineNode,
   createEditor,
   defaultBlockAt,
   defineBaseCommands,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -43,13 +43,13 @@
     "clsx": "^2.1.1",
     "orderedmap": "^2.1.1",
     "prosemirror-splittable": "^0.1.1",
-    "type-fest": "^4.21.0",
-    "@prosekit/pm": "^0.1.6"
+    "type-fest": "^4.22.1",
+    "@prosekit/pm": "^0.1.7"
   },
   "devDependencies": {
-    "tsup": "^8.1.0",
+    "tsup": "^8.1.2",
     "typescript": "^5.5.3",
-    "vitest": "^2.0.2",
+    "vitest": "^2.0.3",
     "@prosekit/dev": "0.0.0"
   },
   "scripts": {