@prosekit/core 0.0.0-next-20240626133927 → 0.0.0-next-20240715024943

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

@@ -1,6 +1,5 @@
 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';
@@ -15,9 +14,7 @@ import type { IsEqual } from 'type-fest';
 import { Mark } from '@prosekit/pm/model';
 import type { MarkSpec } from '@prosekit/pm/model';
 import { MarkType } from '@prosekit/pm/model';
-import { MarkType as MarkType_2 } from 'prosemirror-model';
-import { Node as Node_2 } from 'prosemirror-model';
-import type { Node as Node_3 } from '@prosekit/pm/model';
+import type { Node as Node_2 } from '@prosekit/pm/model';
 import { NodeSelection } from '@prosekit/pm/state';
 import type { NodeSpec } from '@prosekit/pm/model';
 import { NodeType } from '@prosekit/pm/model';
@@ -25,6 +22,7 @@ import { NodeType as NodeType_2 } from 'prosemirror-model';
 import { NodeView } from '@prosekit/pm/view';
 import { NodeViewConstructor } from '@prosekit/pm/view';
 import { Options } from 'tsup';
+import type { ParseOptions } from '@prosekit/pm/model';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
 import { ProseMirrorFragment } from '@prosekit/pm/model';
 import { ProseMirrorNode } from '@prosekit/pm/model';
@@ -49,7 +47,14 @@ declare type Action = (options: {
  *
  * @public
  */
-declare function addMark(options: {
+declare function addMark(options: AddMarkOptions): Command;
+export { addMark }
+export { addMark as addMark_alias_1 }
+
+/**
+ * @public
+ */
+declare interface AddMarkOptions {
     /**
      * The type of the mark to add.
      */
@@ -66,9 +71,9 @@ declare function addMark(options: {
      * 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 { AddMarkOptions }
+export { AddMarkOptions as AddMarkOptions_alias_1 }
 
 export declare function applyAction(operator: Action): Command;
 
@@ -168,7 +173,7 @@ declare type ClickHandler = (view: EditorView, pos: number, event: MouseEvent) =
 export { ClickHandler }
 export { ClickHandler as ClickHandler_alias_1 }
 
-declare type ClickOnHandler = (view: EditorView, pos: number, node: Node_3, nodePos: number, event: MouseEvent, direct: boolean) => boolean | void;
+declare type ClickOnHandler = (view: EditorView, pos: number, node: Node_2, nodePos: number, event: MouseEvent, direct: boolean) => boolean | void;
 export { ClickOnHandler }
 export { ClickOnHandler as ClickOnHandler_alias_1 }
 
@@ -183,7 +188,14 @@ declare const clsx: (...args: Array<string | boolean | null | undefined>) => str
 export { clsx }
 export { clsx as clsx_alias_1 }
 
-export declare function collectNodes(content: NodeContent): ProseMirrorNode[];
+/**
+ * Collects all nodes from a given content.
+ *
+ * @public
+ */
+declare function collectNodes(content: NodeContent): ProseMirrorNode[];
+export { collectNodes }
+export { collectNodes as collectNodes_alias_1 }
 
 export declare function combineEventHandlers<Handler extends (...args: any[]) => boolean | void, Args extends Parameters<Handler> = Parameters<Handler>>(): readonly [(handlers: Handler[]) => void, (...args: Args) => boolean];
 
@@ -287,49 +299,16 @@ declare function defineBaseCommands(): Extension<{
             from?: number;
             to?: number;
         }];
-        insertNode: [options: {
-            node: Node_2;
-            pos?: number;
-            type?: undefined;
-            attrs?: undefined;
-        } | {
-            node?: undefined;
-            pos?: number;
-            type: string;
-            attrs?: Attrs_2;
-        }];
-        removeNode: [options: {
-            type: string | NodeType_2;
-            pos?: number;
-        }];
-        wrap: [{
-            nodeType: NodeType_2;
-            attrs?: Attrs_2 | null;
-        }];
-        setBlockType: [options: {
-            type: NodeType_2 | string;
-            attrs?: Attrs_2 | null;
-            from?: number;
-            to?: number;
-        }];
-        setNodeAttrs: [options: {
-            type: string | NodeType_2 | string[] | NodeType_2[];
-            attrs: Attrs_2;
-            pos?: number;
-        }];
+        insertNode: [options: InsertNodeOptions];
+        removeNode: [options: RemoveNodeOptions];
+        wrap: [WrapOptions];
+        setBlockType: [options: SetBlockTypeOptions];
+        setNodeAttrs: [options: SetNodeAttrsOptions];
         selectAll: [];
-        addMark: [options: {
-            type: string | MarkType_2;
-            attrs?: Attrs_2 | null;
-            from?: number;
-            to?: number;
-        }];
-        removeMark: [options: {
-            type: string | MarkType_2;
-            attrs?: Attrs_2 | null;
-            from?: number;
-            to?: number;
-        }];
+        addMark: [options: AddMarkOptions];
+        removeMark: [options: RemoveMarkOptions];
+        unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
+        unsetMark: [options?: UnsetMarkOptions | undefined];
     };
     Nodes: never;
     Marks: never;
@@ -486,13 +465,15 @@ export { defineFocusChangeHandler as defineFocusChangeHandler_alias_1 }
 
 /**
  * Add undo/redo history to the editor.
+ *
+ * @public
  */
-declare function defineHistory(): Extension<    {
+declare function defineHistory({ depth, newGroupDelay, }?: HistoryOptions): Extension<    {
 Nodes: never;
 Marks: never;
 Commands: {
-undo: [];
-redo: [];
+readonly undo: [];
+readonly redo: [];
 };
 }>;
 export { defineHistory }
@@ -576,6 +557,13 @@ declare function defineNodeView(options: NodeViewOptions): Extension;
 export { defineNodeView }
 export { defineNodeView as defineNodeView_alias_1 }
 
+/**
+ * @internal
+ */
+declare function defineNodeViewComponent<T>(options: NodeViewComponentOptions<T>): Extension;
+export { defineNodeViewComponent }
+export { defineNodeViewComponent as defineNodeViewComponent_alias_1 }
+
 /**
  * @internal
  */
@@ -642,61 +630,28 @@ export { defineScrollToSelectionHandler as defineScrollToSelectionHandler_alias_
 /**
  * @internal
  */
-export declare function defineTestExtension(): Extension<    {
-Nodes: "text" | "doc" | "paragraph";
-Marks: "bold";
-Commands: {
-undo: [];
-redo: [];
-insertText: [{
-text: string;
-from?: number;
-to?: number;
-}];
-insertNode: [options: {
-node: Node_2;
-pos?: number;
-type?: undefined;
-attrs?: undefined;
-} | {
-node?: undefined;
-pos?: number;
-type: string;
-attrs?: Attrs_2;
-}];
-removeNode: [options: {
-type: string | NodeType_2;
-pos?: number;
-}];
-wrap: [{
-nodeType: NodeType_2;
-attrs?: Attrs_2 | null;
-}];
-setBlockType: [options: {
-type: NodeType_2 | string;
-attrs?: Attrs_2 | null;
-from?: number;
-to?: number;
-}];
-setNodeAttrs: [options: {
-type: string | NodeType_2 | string[] | NodeType_2[];
-attrs: Attrs_2;
-pos?: number;
-}];
-selectAll: [];
-addMark: [options: {
-type: string | MarkType_2;
-attrs?: Attrs_2 | null;
-from?: number;
-to?: number;
-}];
-removeMark: [options: {
-type: string | MarkType_2;
-attrs?: Attrs_2 | null;
-from?: number;
-to?: number;
-}];
-};
+export declare function defineTestExtension(): Extension<{
+    Nodes: "text" | "doc" | "paragraph" | "heading";
+    Marks: "bold" | "italic";
+    Commands: {
+        insertText: [{
+            text: string;
+            from?: number;
+            to?: number;
+        }];
+        insertNode: [options: InsertNodeOptions];
+        removeNode: [options: RemoveNodeOptions];
+        wrap: [WrapOptions];
+        setBlockType: [options: SetBlockTypeOptions];
+        setNodeAttrs: [options: SetNodeAttrsOptions];
+        selectAll: [];
+        addMark: [options: AddMarkOptions];
+        removeMark: [options: RemoveMarkOptions];
+        unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
+        unsetMark: [options?: UnsetMarkOptions | undefined];
+        readonly undo: [];
+        readonly redo: [];
+    };
 }>;
 
 /**
@@ -775,9 +730,9 @@ export declare class DOMDocumentNotFoundError extends ProseKitError {
 }
 
 /** @public */
-declare type DOMDocumentOptions = {
+declare interface DOMDocumentOptions {
     document?: Document;
-};
+}
 export { DOMDocumentOptions }
 export { DOMDocumentOptions as DOMDocumentOptions_alias_1 }
 
@@ -806,16 +761,16 @@ export declare type DOMEventPayload = [event: string, handler: DOMEventHandler];
 export declare type DOMNode = InstanceType<typeof window.Node>;
 
 /** @public */
-declare type DOMParserOptions = {
+declare interface DOMParserOptions extends ParseOptions {
     DOMParser?: typeof DOMParser_2;
-};
+}
 export { DOMParserOptions }
 export { DOMParserOptions as DOMParserOptions_alias_1 }
 
 /** @public */
-declare type DOMSerializerOptions = {
+declare interface DOMSerializerOptions {
     DOMSerializer?: typeof DOMSerializer;
-};
+}
 export { DOMSerializerOptions }
 export { DOMSerializerOptions as DOMSerializerOptions_alias_1 }
 
@@ -823,7 +778,7 @@ declare type DoubleClickHandler = (view: EditorView, pos: number, event: MouseEv
 export { DoubleClickHandler }
 export { DoubleClickHandler as DoubleClickHandler_alias_1 }
 
-declare type DoubleClickOnHandler = (view: EditorView, pos: number, node: Node_3, nodePos: number, event: MouseEvent, direct: boolean) => boolean | void;
+declare type DoubleClickOnHandler = (view: EditorView, pos: number, node: Node_2, nodePos: number, event: MouseEvent, direct: boolean) => boolean | void;
 export { DoubleClickOnHandler }
 export { DoubleClickOnHandler as DoubleClickOnHandler_alias_1 }
 
@@ -997,14 +952,21 @@ export { elementFromNode as elementFromNode_alias_1 }
  *
  * @public
  */
-declare function expandMark(options: {
+declare function expandMark(options: ExpandMarkOptions): Command;
+export { expandMark }
+export { expandMark as expandMark_alias_1 }
+
+/**
+ * @public
+ */
+declare interface ExpandMarkOptions {
     /**
      * The type of the mark to expand.
      */
     type: string | MarkType;
-}): Command;
-export { expandMark }
-export { expandMark as expandMark_alias_1 }
+}
+export { ExpandMarkOptions }
+export { ExpandMarkOptions as ExpandMarkOptions_alias_1 }
 
 /**
  * @public
@@ -1211,6 +1173,30 @@ export declare type GroupedEntries<T extends Record<string, any>> = {
 
 export declare function groupEntries<T extends Record<string, any>>(entries: ObjectEntries<T>[]): GroupedEntries<T>;
 
+/**
+ * Options for {@link defineHistory}.
+ *
+ * @public
+ */
+declare interface HistoryOptions {
+    /**
+     * The amount of history events that are collected before the oldest events
+     * are discarded.
+     *
+     * @default 200
+     */
+    depth?: number;
+    /**
+     * The delay in milliseconds between changes after which a new group should be
+     * started.
+     *
+     * @default 250
+     */
+    newGroupDelay?: number;
+}
+export { HistoryOptions }
+export { HistoryOptions as HistoryOptions_alias_1 }
+
 /**
  * @internal
  */
@@ -1240,17 +1226,7 @@ export { htmlFromNode as htmlFromNode_alias_1 }
  *
  * @public
  */
-declare function insertNode(options: {
-    node: ProseMirrorNode;
-    pos?: number;
-    type?: undefined;
-    attrs?: undefined;
-} | {
-    node?: undefined;
-    pos?: number;
-    type: string;
-    attrs?: Attrs;
-}): Command;
+declare function insertNode(options: InsertNodeOptions): Command;
 export { insertNode }
 export { insertNode as insertNode_alias_1 }
 
@@ -1259,6 +1235,31 @@ export declare function insertNodeAction({ node, pos, }: {
     pos?: number;
 }): Action;
 
+/**
+ * @public
+ */
+declare interface InsertNodeOptions {
+    /**
+     * The node to insert. Either this or `type` must be provided.
+     */
+    node?: ProseMirrorNode;
+    /**
+     * The type of the node to insert. Either this or `node` must be provided.
+     */
+    type?: string | NodeType;
+    /**
+     * When `type` is provided, the attributes of the node to insert.
+     */
+    attrs?: Attrs;
+    /**
+     * The position to insert the node at. By default it will be the anchor
+     * position of current selection.
+     */
+    pos?: number;
+}
+export { InsertNodeOptions }
+export { InsertNodeOptions as InsertNodeOptions_alias_1 }
+
 /**
  * Returns a command that inserts the given text.
  *
@@ -1284,6 +1285,15 @@ declare const isApple: boolean;
 export { isApple }
 export { isApple as isApple_alias_1 }
 
+/**
+ * Whether the selection is an empty text selection at the start of a block.
+ *
+ * @internal
+ */
+declare function isAtBlockStart(state: EditorState, view?: EditorView): ResolvedPos | null;
+export { isAtBlockStart }
+export { isAtBlockStart as isAtBlockStart_alias_1 }
+
 export declare function isElement(value: unknown): value is Element;
 
 /**
@@ -1379,9 +1389,9 @@ export { jsonFromState }
 export { jsonFromState as jsonFromState_alias_1 }
 
 /** @public */
-declare type JSONParserOptions = {
+declare interface JSONParserOptions {
     schema: Schema;
-};
+}
 export { JSONParserOptions }
 export { JSONParserOptions as JSONParserOptions_alias_1 }
 
@@ -1541,7 +1551,12 @@ export { NodeBuilder as NodeBuilder_alias_1 }
  */
 export declare type NodeChild = ProseMirrorNode | string | NodeChild[];
 
-export declare type NodeContent = ProseMirrorNode | ProseMirrorFragment | NodeContent[];
+/**
+ * @public
+ */
+declare type NodeContent = ProseMirrorNode | ProseMirrorFragment | NodeContent[];
+export { NodeContent }
+export { NodeContent as NodeContent_alias_1 }
 
 /**
  * Parse a HTML element to a ProseMirror node.
@@ -1598,13 +1613,19 @@ export { NodeSpecOptions as NodeSpecOptions_alias_1 }
 /**
  * @internal
  */
-declare type NodeViewFactoryOptions<T> = {
+declare type NodeViewComponentOptions<T> = {
     group: string;
     name: string;
     args: T;
-} | {
+};
+export { NodeViewComponentOptions }
+export { NodeViewComponentOptions as NodeViewComponentOptions_alias_1 }
+
+/**
+ * @internal
+ */
+declare type NodeViewFactoryOptions<T> = {
     group: string;
-    name?: undefined;
     factory: (args: T) => NodeViewConstructor;
 };
 export { NodeViewFactoryOptions }
@@ -1708,7 +1729,14 @@ export { ProseKitError as ProseKitError_alias_1 }
  *
  * @public
  */
-declare function removeMark(options: {
+declare function removeMark(options: RemoveMarkOptions): Command;
+export { removeMark }
+export { removeMark as removeMark_alias_1 }
+
+/**
+ * @public
+ */
+declare interface RemoveMarkOptions {
     /**
      * The type of the mark to remove.
      */
@@ -1725,16 +1753,23 @@ declare function removeMark(options: {
      * 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 { RemoveMarkOptions }
+export { RemoveMarkOptions as RemoveMarkOptions_alias_1 }
 
 /**
  * Returns a command to remove the nearest ancestor node of a specific type from the current position.
  *
  * @public
  */
-declare function removeNode(options: {
+declare function removeNode(options: RemoveNodeOptions): Command;
+export { removeNode }
+export { removeNode as removeNode_alias_1 }
+
+/**
+ * @public
+ */
+declare interface RemoveNodeOptions {
     /**
      * The type of the node to remove.
      */
@@ -1743,9 +1778,9 @@ declare function removeNode(options: {
      * The document position to start searching node. By default it will be the anchor position of current selection.
      */
     pos?: number;
-}): Command;
-export { removeNode }
-export { removeNode as removeNode_alias_1 }
+}
+export { RemoveNodeOptions }
+export { RemoveNodeOptions as RemoveNodeOptions_alias_1 }
 
 export declare const rootFacet: Facet<RootPayload, RootOutput>;
 
@@ -1799,21 +1834,35 @@ export { SelectionJSON as SelectionJSON_alias_1 }
  *
  * @public
  */
-declare function setBlockType(options: {
+declare function setBlockType(options: SetBlockTypeOptions): Command;
+export { setBlockType }
+export { setBlockType as setBlockType_alias_1 }
+
+/**
+ * @public
+ */
+declare interface SetBlockTypeOptions {
     type: NodeType | string;
     attrs?: Attrs | null;
     from?: number;
     to?: number;
-}): Command;
-export { setBlockType }
-export { setBlockType as setBlockType_alias_1 }
+}
+export { SetBlockTypeOptions }
+export { SetBlockTypeOptions as SetBlockTypeOptions_alias_1 }
 
 /**
  * Returns a command that set the attributes of the current node.
  *
  * @public
  */
-declare function setNodeAttrs(options: {
+declare function setNodeAttrs(options: SetNodeAttrsOptions): Command;
+export { setNodeAttrs }
+export { setNodeAttrs as setNodeAttrs_alias_1 }
+
+/**
+ * @public
+ */
+declare interface SetNodeAttrsOptions {
     /**
      * The type of node to set the attributes of.
      *
@@ -1829,9 +1878,9 @@ declare function setNodeAttrs(options: {
      * containing the current selection.
      */
     pos?: number;
-}): Command;
-export { setNodeAttrs }
-export { setNodeAttrs as setNodeAttrs_alias_1 }
+}
+export { SetNodeAttrsOptions }
+export { SetNodeAttrsOptions as SetNodeAttrsOptions_alias_1 }
 
 export declare function setSelectionAround(tr: Transaction, pos: number): void;
 
@@ -1845,6 +1894,46 @@ export declare type Setter<T> = (value: T) => void;
  */
 export declare function setupEditorExtension<E extends Extension>(options: EditorOptions<E>): E;
 
+/**
+ * @internal
+ */
+export declare function setupTest(): {
+    editor: TestEditor<Extension<{
+        Nodes: "text" | "doc" | "paragraph" | "heading";
+        Marks: "bold" | "italic";
+        Commands: {
+            insertText: [{
+                text: string;
+                from?: number;
+                to?: number;
+            }];
+            insertNode: [options: InsertNodeOptions];
+            removeNode: [options: RemoveNodeOptions];
+            wrap: [WrapOptions];
+            setBlockType: [options: SetBlockTypeOptions];
+            setNodeAttrs: [options: SetNodeAttrsOptions];
+            selectAll: [];
+            addMark: [options: AddMarkOptions];
+            removeMark: [options: RemoveMarkOptions];
+            unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
+            unsetMark: [options?: UnsetMarkOptions | undefined];
+            readonly undo: [];
+            readonly redo: [];
+        };
+    }>>;
+    n: Record<"text" | "doc" | "paragraph" | "heading", NodeBuilder>;
+    m: Record<"bold" | "italic", MarkBuilder>;
+};
+
+/**
+ * @internal
+ */
+export declare function setupTestFromExtension<E extends Extension>(extension: E): {
+    editor: TestEditor<E>;
+    n: Record<ExtractNodes<E>, NodeBuilder>;
+    m: Record<ExtractMarks<E>, MarkBuilder>;
+};
+
 /**
  * @internal
  */
@@ -1885,6 +1974,21 @@ export declare type StatePayload = (ctx: {
     schema: Schema;
 }) => EditorStateConfig;
 
+/**
+ * A JSON representation of the prosemirror step.
+ *
+ * @public
+ */
+declare interface StepJSON {
+    /**
+     * The type of the step.
+     */
+    stepType: string;
+    [x: string]: unknown;
+}
+export { StepJSON }
+export { StepJSON as StepJSON_alias_1 }
+
 /**
  * Takes two facet nodes and returns a new facet node containing inputs and
  * children from the first node but not the second.
@@ -1943,33 +2047,53 @@ export declare type ToCommandCreators<T extends CommandTyping> = {
  *
  * @public
  */
-declare function toggleMark({ type, attrs, }: {
-    type: string | MarkType;
-    attrs?: Attrs | null;
-}): Command;
+declare function toggleMark({ type, attrs }: ToggleMarkOptions): Command;
 export { toggleMark }
 export { toggleMark as toggleMark_alias_1 }
 
+/**
+ * @public
+ */
+declare interface ToggleMarkOptions {
+    type: string | MarkType;
+    attrs?: Attrs | null;
+}
+export { ToggleMarkOptions }
+export { ToggleMarkOptions as ToggleMarkOptions_alias_1 }
+
 /**
  * Returns a command that set the selected textblocks to the given node type
  * with the given attributes.
  *
  * @public
  */
-declare function toggleNode({ type, attrs, }: {
-    type: string | NodeType;
-    attrs?: Attrs | null;
-}): Command;
+declare function toggleNode({ type, attrs }: ToggleNodeOptions): Command;
 export { toggleNode }
 export { toggleNode as toggleNode_alias_1 }
 
+/**
+ * @public
+ */
+declare interface ToggleNodeOptions {
+    /**
+     * The type of the node to toggle.
+     */
+    type: string | NodeType;
+    /**
+     * The attributes of the node to toggle.
+     */
+    attrs?: Attrs | null;
+}
+export { ToggleNodeOptions }
+export { ToggleNodeOptions as ToggleNodeOptions_alias_1 }
+
 export declare function toReversed<T>(arr: T[]): T[];
 
 declare type TripleClickHandler = (view: EditorView, pos: number, event: MouseEvent) => boolean | void;
 export { TripleClickHandler }
 export { TripleClickHandler as TripleClickHandler_alias_1 }
 
-declare type TripleClickOnHandler = (view: EditorView, pos: number, node: Node_3, nodePos: number, event: MouseEvent, direct: boolean) => boolean | void;
+declare type TripleClickOnHandler = (view: EditorView, pos: number, node: Node_2, nodePos: number, event: MouseEvent, direct: boolean) => boolean | void;
 export { TripleClickOnHandler }
 export { TripleClickOnHandler as TripleClickOnHandler_alias_1 }
 
@@ -1983,6 +2107,17 @@ export declare type Tuple5<T> = [T, T, T, T, T];
  *
  * @throws If no extensions are provided.
  *
+ * @example
+ *
+ * ```ts
+ * function defineFancyNodes() {
+ *   return union([
+ *     defineFancyParagraph(),
+ *     defineFancyHeading(),
+ *   ])
+ * }
+ * ```
+ *
  * @public
  */
 declare function union<const E extends Extension | readonly Extension[]>(extension: E): UnionExtension<E>;
@@ -2035,6 +2170,57 @@ declare type UnmountHandler = () => void;
 export { UnmountHandler }
 export { UnmountHandler as UnmountHandler_alias_1 }
 
+/**
+ * Returns a command that set the type of all textblocks between the given range
+ * to the default type (usually `paragraph`).
+ *
+ * @public
+ */
+declare function unsetBlockType(options?: UnsetBlockTypeOptions): Command;
+export { unsetBlockType }
+export { unsetBlockType as unsetBlockType_alias_1 }
+
+/**
+ * @public
+ */
+declare interface UnsetBlockTypeOptions {
+    /**
+     * The start position of the document. By default it will be the start position of current selection.
+     */
+    from?: number;
+    /**
+     * The end position of the document. By default it will be the end position of current selection.
+     */
+    to?: number;
+}
+export { UnsetBlockTypeOptions }
+export { UnsetBlockTypeOptions as UnsetBlockTypeOptions_alias_1 }
+
+/**
+ * Returns a command that removes all marks.
+ *
+ * @public
+ */
+declare function unsetMark(options?: UnsetMarkOptions): Command;
+export { unsetMark }
+export { unsetMark as unsetMark_alias_1 }
+
+/**
+ * @public
+ */
+declare interface UnsetMarkOptions {
+    /**
+     * The start position of the document. By default it will be the start position of current selection.
+     */
+    from?: number;
+    /**
+     * The end position of the document. By default it will be the end position of current selection.
+     */
+    to?: number;
+}
+export { UnsetMarkOptions }
+export { UnsetMarkOptions as UnsetMarkOptions_alias_1 }
+
 /**
  * A function that is called when the editor state is updated.
  *
@@ -2054,6 +2240,15 @@ export declare type ViewPayload = Omit<DirectEditorProps, 'state'>;
 export declare function voidFunction(): void;
 
 /**
+ * Return an new extension with the given priority.
+ *
+ * @example
+ * ```ts
+ * import { Priority, withPriority } from 'prosekit/core'
+ *
+ * const extension = withPriority(defineMyExtension(), Priority.high)
+ * ```
+ *
  * @public
  */
 declare function withPriority<T extends Extension>(extension: T, priority: Priority): T;
@@ -2073,10 +2268,19 @@ export { withSkipCodeBlock as withSkipCodeBlock_alias_1 }
  *
  * @public
  */
-export declare function wrap({ nodeType, attrs, }: {
+declare function wrap({ nodeType, attrs }: WrapOptions): Command;
+export { wrap }
+export { wrap as wrap_alias_1 }
+
+/**
+ * @public
+ */
+declare interface WrapOptions {
     nodeType: NodeType;
     attrs?: Attrs | null;
-}): Command;
+}
+export { WrapOptions }
+export { WrapOptions as WrapOptions_alias_1 }
 
 export declare function zip<T, P>(a: T[], b: P[]): [T, P][];
 

package/dist/{chunk-W4AZKLNQ.js → chunk-YWQGKV6X.js}

@@ -341,8 +341,8 @@ function nodeFromJSON(json, options) {
   return options.schema.nodeFromJSON(json);
 }
 function nodeFromElement(element, options) {
-  let Parser = options.DOMParser || DOMParser, schema = options.schema;
-  return Parser.fromSchema(schema).parse(element);
+  let { DOMParser: CustomDOMParser, schema, ...parseOptions } = options;
+  return (CustomDOMParser || DOMParser).fromSchema(schema).parse(element, parseOptions);
 }
 function elementFromNode(node, options) {
   let Serializer = (options == null ? void 0 : options.DOMSerializer) || DOMSerializer, document2 = getBrowserDocument(options), schema = node.type.schema, serializer = Serializer.fromSchema(schema);

package/dist/prosekit-core-test.js

@@ -5,7 +5,7 @@ import {
   createMarkBuilders,
   createNodeBuilders,
   setupEditorExtension
-} from "./chunk-W4AZKLNQ.js";
+} from "./chunk-YWQGKV6X.js";
 
 // src/test/test-editor.ts
 import { EditorState, NodeSelection, TextSelection } from "@prosekit/pm/state";

package/dist/prosekit-core.d.ts

@@ -1,12 +1,27 @@
 export { addMark } from './_tsup-dts-rollup';
+export { AddMarkOptions } from './_tsup-dts-rollup';
 export { expandMark } from './_tsup-dts-rollup';
+export { ExpandMarkOptions } from './_tsup-dts-rollup';
 export { insertNode } from './_tsup-dts-rollup';
+export { InsertNodeOptions } from './_tsup-dts-rollup';
 export { removeMark } from './_tsup-dts-rollup';
+export { RemoveMarkOptions } from './_tsup-dts-rollup';
 export { removeNode } from './_tsup-dts-rollup';
+export { RemoveNodeOptions } from './_tsup-dts-rollup';
 export { setBlockType } from './_tsup-dts-rollup';
+export { SetBlockTypeOptions } from './_tsup-dts-rollup';
 export { setNodeAttrs } from './_tsup-dts-rollup';
+export { SetNodeAttrsOptions } from './_tsup-dts-rollup';
 export { toggleMark } from './_tsup-dts-rollup';
+export { ToggleMarkOptions } from './_tsup-dts-rollup';
 export { toggleNode } from './_tsup-dts-rollup';
+export { ToggleNodeOptions } from './_tsup-dts-rollup';
+export { unsetBlockType } from './_tsup-dts-rollup';
+export { UnsetBlockTypeOptions } from './_tsup-dts-rollup';
+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 { MarkBuilder } from './_tsup-dts-rollup';
 export { NodeBuilder } from './_tsup-dts-rollup';
 export { Editor } from './_tsup-dts-rollup';
@@ -58,11 +73,12 @@ export { MountHandler } from './_tsup-dts-rollup';
 export { UnmountHandler } from './_tsup-dts-rollup';
 export { UpdateHandler } from './_tsup-dts-rollup';
 export { defineHistory } from './_tsup-dts-rollup';
-export { defineBaseKeymap } from './_tsup-dts-rollup';
+export { HistoryOptions } from './_tsup-dts-rollup';
 export { defineKeymap } from './_tsup-dts-rollup';
 export { keymapFacet } from './_tsup-dts-rollup';
 export { Keymap } from './_tsup-dts-rollup';
 export { KeymapPayload } from './_tsup-dts-rollup';
+export { defineBaseKeymap } from './_tsup-dts-rollup';
 export { defineMarkAttr } from './_tsup-dts-rollup';
 export { defineMarkSpec } from './_tsup-dts-rollup';
 export { MarkAttrOptions } from './_tsup-dts-rollup';
@@ -73,7 +89,9 @@ export { NodeAttrOptions } from './_tsup-dts-rollup';
 export { NodeSpecOptions } from './_tsup-dts-rollup';
 export { defineNodeView } from './_tsup-dts-rollup';
 export { NodeViewOptions } from './_tsup-dts-rollup';
+export { defineNodeViewComponent } from './_tsup-dts-rollup';
 export { defineNodeViewFactory } from './_tsup-dts-rollup';
+export { NodeViewComponentOptions } from './_tsup-dts-rollup';
 export { NodeViewFactoryOptions } from './_tsup-dts-rollup';
 export { defineParagraph } from './_tsup-dts-rollup';
 export { definePlugin } from './_tsup-dts-rollup';
@@ -95,16 +113,20 @@ export { UnionExtension } 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 { Priority } 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 { defaultBlockAt } from './_tsup-dts-rollup';
 export { isApple } from './_tsup-dts-rollup';
 export { _getId } from './_tsup-dts-rollup';
 export { getMarkType } from './_tsup-dts-rollup';
 export { getNodeType } from './_tsup-dts-rollup';
+export { isAtBlockStart } from './_tsup-dts-rollup';
 export { isInCodeBlock } from './_tsup-dts-rollup';
 export { isMarkAbsent } from './_tsup-dts-rollup';
 export { isMarkActive } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -35,7 +35,7 @@ import {
   stateFromJSON,
   toReversed,
   union
-} from "./chunk-W4AZKLNQ.js";
+} from "./chunk-YWQGKV6X.js";
 
 // src/commands/add-mark.ts
 import "@prosekit/pm/model";
@@ -94,7 +94,7 @@ function insertNode(options) {
     assert(node, "You must provide either a node or a type");
     let insertPos = insertPoint(
       state.doc,
-      (_a = options.pos) != null ? _a : state.selection.to,
+      (_a = options.pos) != null ? _a : state.selection.anchor,
       node.type
     );
     if (insertPos == null) return !1;
@@ -268,10 +268,7 @@ function baseToggleMark(markType, attrs = null, options) {
     return !0;
   };
 }
-function toggleMark({
-  type,
-  attrs
-}) {
+function toggleMark({ type, attrs }) {
   return (state, dispatch, view) => baseToggleMark(getMarkType(state.schema, type), attrs, {
     removeWhenPresent: !1
   })(state, dispatch, view);
@@ -281,10 +278,7 @@ function toggleMark({
 import { setBlockType as setBlockType2 } from "@prosekit/pm/commands";
 import "@prosekit/pm/model";
 import "@prosekit/pm/state";
-function toggleNode({
-  type,
-  attrs
-}) {
+function toggleNode({ type, attrs }) {
   return (state, dispatch, view) => {
     if (isNodeActive(state, type, attrs)) {
       let defaultType = state.schema.topNodeType.contentMatch.defaultType;
@@ -296,6 +290,63 @@ function toggleNode({
   };
 }
 
+// src/commands/unset-block-type.ts
+import { Fragment, Slice } from "@prosekit/pm/model";
+import "@prosekit/pm/state";
+import { ReplaceAroundStep } from "@prosekit/pm/transform";
+function unsetBlockType(options) {
+  return (state, dispatch) => {
+    var _a, _b;
+    let from = (_a = options == null ? void 0 : options.from) != null ? _a : state.selection.from, to = (_b = options == null ? void 0 : options.to) != null ? _b : state.selection.to;
+    if (from > to) return !1;
+    let tr = state.tr;
+    return unsetTextBlockType(tr, from, to) ? (dispatch == null || dispatch(tr), !0) : !1;
+  };
+}
+function unsetTextBlockType(tr, from, to) {
+  let mapFrom = tr.steps.length;
+  return tr.doc.nodesBetween(from, to, (node, pos, parent, index) => {
+    if (!parent || !node.isTextblock) return !0;
+    let defaultType = parent.contentMatchAt(index).defaultType;
+    if (defaultType && defaultType.isTextblock && node.type !== defaultType && defaultType.validContent(node.content)) {
+      let mapping = tr.mapping.slice(mapFrom), start = mapping.map(pos, 1), end = mapping.map(pos + node.nodeSize, 1), step = new ReplaceAroundStep(
+        start,
+        end,
+        start + 1,
+        end - 1,
+        new Slice(Fragment.from(defaultType.create()), 0, 0),
+        1,
+        !0
+      );
+      tr.step(step);
+    }
+    return !1;
+  }), tr.steps.length > mapFrom;
+}
+
+// src/commands/unset-mark.ts
+import "@prosekit/pm/state";
+function unsetMark(options) {
+  return (state, dispatch) => {
+    var _a, _b;
+    let from = (_a = options == null ? void 0 : options.from) != null ? _a : state.selection.from, to = (_b = options == null ? void 0 : options.to) != null ? _b : state.selection.to;
+    return from > to ? !1 : (dispatch == null || dispatch(state.tr.removeMark(from, to)), !0);
+  };
+}
+
+// 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) => {
+    let { $from, $to } = state.selection, range = $from.blockRange($to);
+    if (!range) return !1;
+    let wrapping = findWrapping(range, nodeType, attrs);
+    return wrapping ? (dispatch == null || dispatch(state.tr.wrap(range, wrapping)), !0) : !1;
+  };
+}
+
 // src/editor/with-priority.ts
 function withPriority(extension, priority) {
   let result = union(extension);
@@ -317,22 +368,6 @@ function selectAll() {
   return (state, dispatch) => (dispatch == null || dispatch(state.tr.setSelection(new AllSelection(state.doc))), !0);
 }
 
-// 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) => {
-    let { $from, $to } = state.selection, range = $from.blockRange($to);
-    if (!range) return !1;
-    let wrapping = findWrapping(range, nodeType, attrs);
-    return wrapping ? (dispatch == null || dispatch(state.tr.wrap(range, wrapping)), !0) : !1;
-  };
-}
-
 // src/facets/command.ts
 var commandFacet = defineFacet({
   reducer: (inputs) => ({ commands: Object.assign({}, ...inputs) }),
@@ -341,8 +376,8 @@ var commandFacet = defineFacet({
 });
 
 // src/extensions/command.ts
-function defineCommands(commands) {
-  return defineFacetPayload(commandFacet, [commands]);
+function defineCommands(commands2) {
+  return defineFacetPayload(commandFacet, [commands2]);
 }
 function defineBaseCommands() {
   return defineCommands({
@@ -354,7 +389,9 @@ function defineBaseCommands() {
     setNodeAttrs,
     selectAll,
     addMark,
-    removeMark
+    removeMark,
+    unsetBlockType,
+    unsetMark
   });
 }
 
@@ -584,7 +621,7 @@ function defineDOMEventHandler(event, handler) {
 }
 var domEventFacet = defineFacet({
   reduce: () => {
-    let setHandlersMap = {}, combinedHandlerMap = {}, plugin = null, update = (payloads) => {
+    let setHandlersMap = {}, combinedHandlerMap = {}, plugin, update = (payloads) => {
       var _a;
       let hasNewEvent = !1;
       for (let [event] of payloads)
@@ -699,36 +736,15 @@ import { history, redo, undo } from "@prosekit/pm/history";
 var isApple = typeof navigator != "undefined" ? /Mac|iP(hone|[ao]d)/.test(navigator.platform) : !1;
 
 // src/extensions/keymap.ts
-import {
-  baseKeymap,
-  chainCommands,
-  createParagraphNear,
-  liftEmptyBlock,
-  newlineInCode
-} from "@prosekit/pm/commands";
+import { chainCommands } from "@prosekit/pm/commands";
 import { keydownHandler } from "@prosekit/pm/keymap";
 import { Plugin as Plugin2, PluginKey as PluginKey4 } from "@prosekit/pm/state";
-import { splitSplittableBlock } from "prosemirror-splittable";
-var customBaseKeymap = {
-  ...baseKeymap,
-  Enter: chainCommands(
-    newlineInCode,
-    createParagraphNear,
-    liftEmptyBlock,
-    splitSplittableBlock
-  )
-};
-function defineKeymap(keymap) {
-  return defineFacetPayload(keymapFacet, [keymap]);
-}
-function defineBaseKeymap(options) {
-  var _a;
-  let priority = (_a = options == null ? void 0 : options.priority) != null ? _a : 1 /* low */;
-  return withPriority(defineKeymap(customBaseKeymap), priority);
+function defineKeymap(keymap2) {
+  return defineFacetPayload(keymapFacet, [keymap2]);
 }
 var keymapFacet = defineFacet({
   reduce: () => {
-    let handler = null, handlerWrapper = (view, event) => handler ? handler(view, event) : !1, plugin = new Plugin2({
+    let handler, handlerWrapper = (view, event) => handler ? handler(view, event) : !1, plugin = new Plugin2({
       key: keymapPluginKey,
       props: { handleKeyDown: handlerWrapper }
     });
@@ -744,34 +760,71 @@ var keymapFacet = defineFacet({
 });
 function mergeKeymaps(keymaps) {
   let bindings = {};
-  for (let keymap of keymaps)
-    for (let [key, command] of Object.entries(keymap))
+  for (let keymap2 of keymaps)
+    for (let [key, command] of Object.entries(keymap2))
       (bindings[key] || (bindings[key] = [])).push(command);
   return Object.fromEntries(
-    Object.entries(bindings).map(([key, commands]) => [
+    Object.entries(bindings).map(([key, commands2]) => [
       key,
-      chainCommands(...commands)
+      chainCommands(...commands2)
     ])
   );
 }
 var keymapPluginKey = new PluginKey4("prosekit-keymap");
 
 // src/extensions/history.ts
-function defineHistory() {
-  let keymap = {
-    "Mod-z": undo,
-    "Shift-Mod-z": redo
-  };
-  return isApple || (keymap["Mod-y"] = redo), union([
-    definePlugin(history()),
+var keymap = {
+  "Mod-z": undo,
+  "Shift-Mod-z": redo
+};
+isApple || (keymap["Mod-y"] = redo);
+var commands = {
+  undo: () => undo,
+  redo: () => redo
+};
+function defineHistory({
+  depth = 200,
+  newGroupDelay = 250
+} = {}) {
+  return union([
+    definePlugin(history({ depth, newGroupDelay })),
     defineKeymap(keymap),
-    defineCommands({
-      undo: () => undo,
-      redo: () => redo
-    })
+    defineCommands(commands)
   ]);
 }
 
+// src/extensions/keymap-base.ts
+import {
+  baseKeymap,
+  chainCommands as chainCommands2,
+  createParagraphNear,
+  deleteSelection,
+  joinTextblockBackward,
+  liftEmptyBlock,
+  newlineInCode,
+  selectNodeBackward
+} from "@prosekit/pm/commands";
+import { splitSplittableBlock } from "prosemirror-splittable";
+var customEnter = chainCommands2(
+  newlineInCode,
+  createParagraphNear,
+  liftEmptyBlock,
+  splitSplittableBlock
+), customBackspace = chainCommands2(
+  deleteSelection,
+  joinTextblockBackward,
+  selectNodeBackward
+), customBaseKeymap = {
+  ...baseKeymap,
+  Enter: customEnter,
+  Backspace: customBackspace
+};
+function defineBaseKeymap(options) {
+  var _a;
+  let priority = (_a = options == null ? void 0 : options.priority) != null ? _a : 1 /* low */;
+  return withPriority(defineKeymap(customBaseKeymap), priority);
+}
+
 // src/extensions/mark-spec.ts
 function defineMarkSpec(options) {
   return defineFacetPayload(markSpecFacet, [[options, void 0]]);
@@ -859,22 +912,17 @@ var nodeViewFacet = defineFacet({
 import { PluginKey as PluginKey6, ProseMirrorPlugin as ProseMirrorPlugin6 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
 function defineNodeViewFactory(options) {
-  return defineFacetPayload(nodeViewFactoryFacet, [options]);
+  return defineFacetPayload(nodeViewFactoryFacet, [[options, null]]);
+}
+function defineNodeViewComponent(options) {
+  return defineFacetPayload(nodeViewFactoryFacet, [[null, options]]);
 }
 var nodeViewFactoryFacet = defineFacet({
   reducer: (inputs) => {
-    let nodeViews = {}, options = {}, factories = {};
-    for (let input of inputs) {
-      let group = input.group;
-      input.name == null ? factories[group] = input.factory : (options[group] || (options[group] = []), options[group].push({
-        name: input.name,
-        args: input.args
-      }));
-    }
-    for (let [group, factory] of Object.entries(factories)) {
-      let groupOptions = options[group] || [];
-      for (let { name, args } of groupOptions)
-        nodeViews[name] = factory(args);
+    let nodeViews = {}, factories = inputs.map((x) => x[0]).filter(isNotNull), options = inputs.map((x) => x[1]).filter(isNotNull);
+    for (let { group, name, args } of options) {
+      let factory = factories.find((factory2) => factory2.group === group);
+      factory && (nodeViews[name] = factory.factory(args));
     }
     return () => [
       new ProseMirrorPlugin6({
@@ -929,6 +977,22 @@ var canUseRegexLookbehind = cache(() => {
 import clsxLite from "clsx/lite";
 var clsx = clsxLite;
 
+// src/utils/collect-nodes.ts
+import { ProseMirrorFragment, ProseMirrorNode as ProseMirrorNode2 } from "@prosekit/pm/model";
+function collectNodes(content) {
+  if (Array.isArray(content))
+    return content.flatMap(collectNodes);
+  if (content instanceof ProseMirrorNode2)
+    return [content];
+  if (content instanceof ProseMirrorFragment) {
+    let nodes = [];
+    for (let i = 0; i < content.childCount; i++)
+      nodes.push(content.child(i));
+    return nodes;
+  }
+  throw new ProseKitError(`Invalid node content: ${typeof content}`);
+}
+
 // src/utils/default-block-at.ts
 function defaultBlockAt(match) {
   for (let i = 0; i < match.edgeCount; i++) {
@@ -944,6 +1008,12 @@ function getId() {
   return id = (id + 1) % Number.MAX_SAFE_INTEGER, `id:${id}`;
 }
 
+// src/utils/is-at-block-start.ts
+function isAtBlockStart(state, view) {
+  let { $cursor } = state.selection;
+  return !$cursor || (view ? !view.endOfTextblock("backward", state) : $cursor.parentOffset > 0) ? null : $cursor;
+}
+
 // src/utils/is-in-code-block.ts
 function isCodeBlockType(type) {
   return type.spec.code && type.isBlock;
@@ -975,6 +1045,7 @@ export {
   assert,
   canUseRegexLookbehind,
   clsx,
+  collectNodes,
   createEditor,
   defaultBlockAt,
   defineBaseCommands,
@@ -1002,6 +1073,7 @@ export {
   defineNodeAttr,
   defineNodeSpec,
   defineNodeView,
+  defineNodeViewComponent,
   defineNodeViewFactory,
   defineParagraph,
   definePasteHandler,
@@ -1023,6 +1095,7 @@ export {
   insertNode,
   isAllSelection,
   isApple,
+  isAtBlockStart,
   isInCodeBlock,
   isMark,
   isMarkAbsent,
@@ -1047,6 +1120,9 @@ export {
   toggleMark,
   toggleNode,
   union,
+  unsetBlockType,
+  unsetMark,
   withPriority,
-  withSkipCodeBlock
+  withSkipCodeBlock,
+  wrap
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.0.0-next-20240626133927",
+  "version": "0.0.0-next-20240715024943",
   "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.20.1",
-    "@prosekit/pm": "^0.0.0-next-20240626133927"
+    "type-fest": "^4.21.0",
+    "@prosekit/pm": "^0.0.0-next-20240715024943"
   },
   "devDependencies": {
     "tsup": "^8.1.0",
-    "typescript": "^5.5.2",
-    "vitest": "^2.0.0-beta.12",
+    "typescript": "^5.5.3",
+    "vitest": "^2.0.2",
     "@prosekit/dev": "0.0.0"
   },
   "scripts": {