@prosekit/core 0.7.0 → 0.7.2

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';
@@ -50,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.
      */
@@ -67,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;
 
@@ -169,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 }
 
@@ -295,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;
@@ -584,6 +555,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
  */
@@ -650,61 +628,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];
+        undo: [];
+        redo: [];
+    };
 }>;
 
 /**
@@ -831,7 +776,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 }
 
@@ -1005,14 +950,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
@@ -1248,17 +1200,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 }
 
@@ -1267,6 +1209,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.
  *
@@ -1292,6 +1259,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;
 
 /**
@@ -1611,13 +1587,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 }
@@ -1721,7 +1703,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.
      */
@@ -1738,16 +1727,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.
      */
@@ -1756,9 +1752,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>;
 
@@ -1812,21 +1808,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.
      *
@@ -1842,9 +1852,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;
 
@@ -1858,6 +1868,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];
+            undo: [];
+            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
  */
@@ -1971,33 +2021,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 }
 
@@ -2074,6 +2144,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.
  *
@@ -2121,10 +2242,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/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';
@@ -18,8 +33,6 @@ export { EditorNotFoundError_alias_1 as EditorNotFoundError } from './_tsup-dts-
 export { ProseKitError_alias_1 as ProseKitError } from './_tsup-dts-rollup';
 export { defineBaseCommands } from './_tsup-dts-rollup';
 export { defineCommands } from './_tsup-dts-rollup';
-export { collectNodes } from './_tsup-dts-rollup';
-export { NodeContent } from './_tsup-dts-rollup';
 export { defineDefaultState } from './_tsup-dts-rollup';
 export { DefaultStateOptions } from './_tsup-dts-rollup';
 export { defineDoc } from './_tsup-dts-rollup';
@@ -60,11 +73,11 @@ 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 { 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';
@@ -75,7 +88,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';
@@ -103,11 +118,14 @@ 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

@@ -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) }),
@@ -354,26 +389,12 @@ function defineBaseCommands() {
     setNodeAttrs,
     selectAll,
     addMark,
-    removeMark
+    removeMark,
+    unsetBlockType,
+    unsetMark
   });
 }
 
-// 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/extensions/node-spec.ts
 import OrderedMap2 from "orderedmap";
 
@@ -715,33 +736,12 @@ 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);
-}
 var keymapFacet = defineFacet({
   reduce: () => {
     let handler, handlerWrapper = (view, event) => handler ? handler(view, event) : !1, plugin = new Plugin2({
@@ -788,6 +788,38 @@ function defineHistory() {
   ]);
 }
 
+// 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]]);
@@ -875,22 +907,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({
@@ -945,6 +972,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++) {
@@ -960,6 +1003,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;
@@ -1019,6 +1068,7 @@ export {
   defineNodeAttr,
   defineNodeSpec,
   defineNodeView,
+  defineNodeViewComponent,
   defineNodeViewFactory,
   defineParagraph,
   definePasteHandler,
@@ -1040,6 +1090,7 @@ export {
   insertNode,
   isAllSelection,
   isApple,
+  isAtBlockStart,
   isInCodeBlock,
   isMark,
   isMarkAbsent,
@@ -1064,6 +1115,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.7.0",
+  "version": "0.7.2",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -49,7 +49,7 @@
   "devDependencies": {
     "tsup": "^8.1.0",
     "typescript": "^5.5.3",
-    "vitest": "^2.0.0-beta.13",
+    "vitest": "^2.0.2",
     "@prosekit/dev": "0.0.0"
   },
   "scripts": {