@prosekit/core 0.2.7 → 0.3.1

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

@@ -5,17 +5,18 @@ import { Command } from '@prosekit/pm/state';
 import type { ConditionalExcept } from 'type-fest';
 import type { ContentMatch } from '@prosekit/pm/model';
 import type { DirectEditorProps } from '@prosekit/pm/view';
+import type { DOMEventMap } from '@prosekit/pm/view';
 import { EditorState } from '@prosekit/pm/state';
 import type { EditorStateConfig } from '@prosekit/pm/state';
 import { EditorView } from '@prosekit/pm/view';
 import type { EmptyObject } from 'type-fest';
-import { InputRule } from '@prosekit/pm/inputrules';
 import type { IsEqual } from 'type-fest';
 import { Mark } from '@prosekit/pm/model';
 import type { MarkSpec } from '@prosekit/pm/model';
 import { MarkType } from '@prosekit/pm/model';
 import { MarkType as MarkType_2 } from 'prosemirror-model';
 import { Node as Node_2 } from 'prosemirror-model';
+import type { Node as Node_3 } from '@prosekit/pm/model';
 import { NodeSelection } from '@prosekit/pm/state';
 import type { NodeSpec } from '@prosekit/pm/model';
 import { NodeType } from '@prosekit/pm/model';
@@ -31,6 +32,7 @@ import type { SchemaSpec } from '@prosekit/pm/model';
 import { Selection as Selection_2 } from '@prosekit/pm/state';
 import { Selection as Selection_3 } from 'prosemirror-state';
 import type { Simplify } from 'type-fest';
+import type { Slice } from '@prosekit/pm/model';
 import { TextSelection } from '@prosekit/pm/state';
 import { Transaction } from '@prosekit/pm/state';
 import type { UnionToIntersection } from 'type-fest';
@@ -123,6 +125,14 @@ declare interface BaseNodeViewOptions {
 export { BaseNodeViewOptions }
 export { BaseNodeViewOptions as BaseNodeViewOptions_alias_1 }
 
+declare type ClickHandler = (view: EditorView, pos: number, event: MouseEvent) => boolean | void;
+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;
+export { ClickOnHandler }
+export { ClickOnHandler as ClickOnHandler_alias_1 }
+
 /**
  * A utility for constructing `className` strings conditionally.
  *
@@ -136,6 +146,8 @@ export { clsx as clsx_alias_1 }
 
 export declare function collectNodes(content: NodeContent): ProseMirrorNode[];
 
+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[]> {
     (...args: Args): boolean;
     canApply(...args: Args): boolean;
@@ -282,6 +294,24 @@ declare function defineBaseKeymap(options?: {
 export { defineBaseKeymap }
 export { defineBaseKeymap as defineBaseKeymap_alias_1 }
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleClick}
+ */
+declare function defineClickHandler(handler: ClickHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineClickHandler }
+export { defineClickHandler as defineClickHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleClickOn}
+ */
+declare function defineClickOnHandler(handler: ClickOnHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineClickOnHandler }
+export { defineClickOnHandler as defineClickOnHandler_alias_1 }
+
 declare function defineCommands<T extends Record<string, CommandCreator> = Record<string, CommandCreator>>(commands: T): Extension<{
     COMMAND_ARGS: {
         [K in keyof T]: Parameters<T[K]>;
@@ -312,6 +342,42 @@ declare function defineDocChangeHandler(handler: DocChangeHandler): Extension<Ex
 export { defineDocChangeHandler }
 export { defineDocChangeHandler as defineDocChangeHandler_alias_1 }
 
+/**
+ * Register a new event handler for the given event type.
+ *
+ * @public
+ */
+declare function defineDOMEventHandler<Event extends keyof DOMEventMap = string>(event: Event, handler: DOMEventHandler<Event>): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineDOMEventHandler }
+export { defineDOMEventHandler as defineDOMEventHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleDoubleClick}
+ */
+declare function defineDoubleClickHandler(handler: DoubleClickHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineDoubleClickHandler }
+export { defineDoubleClickHandler as defineDoubleClickHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleDoubleClickOn}
+ */
+declare function defineDoubleClickOnHandler(handler: DoubleClickOnHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineDoubleClickOnHandler }
+export { defineDoubleClickOnHandler as defineDoubleClickOnHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleDrop}
+ */
+declare function defineDropHandler(handler: DropHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineDropHandler }
+export { defineDropHandler as defineDropHandler_alias_1 }
+
 /**
  * Registers a event handler that is called when the editor gains or loses focus.
  *
@@ -334,20 +400,13 @@ export { defineHistory }
 export { defineHistory as defineHistory_alias_1 }
 
 /**
- * Defines an input rule extension.
- *
- * @param rule - The ProseMirror input rule to add, or an array of input rules,
- * or a function that returns one or multiple input rules.
- *
  * @public
  *
- * @deprecated Use `prosekit/extensions/input-rule` instead.
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleKeyDown}
  */
-declare function defineInputRule(rule: InputRule | InputRule[] | ((context: {
-    schema: Schema;
-}) => InputRule | InputRule[])): Extension;
-export { defineInputRule }
-export { defineInputRule as defineInputRule_alias_1 }
+declare function defineKeyDownHandler(handler: KeyDownHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineKeyDownHandler }
+export { defineKeyDownHandler as defineKeyDownHandler_alias_1 }
 
 /**
  * @public
@@ -356,6 +415,15 @@ declare function defineKeymap(keymap: Keymap): Extension;
 export { defineKeymap }
 export { defineKeymap as defineKeymap_alias_1 }
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleKeyPress}
+ */
+declare function defineKeyPressHandler(handler: KeyPressHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineKeyPressHandler }
+export { defineKeyPressHandler as defineKeyPressHandler_alias_1 }
+
 /**
  * @public
  */
@@ -432,6 +500,15 @@ export declare function defineParagraphSpec(): Extension<    {
 NODES: "paragraph";
 }>;
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handlePaste}
+ */
+declare function definePasteHandler(handler: PasteHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { definePasteHandler }
+export { definePasteHandler as definePasteHandler_alias_1 }
+
 /**
  * Adds a ProseMirror plugin to the editor.
  *
@@ -446,6 +523,15 @@ declare function definePlugin(plugin: Plugin_2 | Plugin_2[] | ((context: {
 export { definePlugin }
 export { definePlugin as definePlugin_alias_1 }
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleScrollToSelection}
+ */
+declare function defineScrollToSelectionHandler(handler: ScrollToSelectionHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineScrollToSelectionHandler }
+export { defineScrollToSelectionHandler as defineScrollToSelectionHandler_alias_1 }
+
 /**
  * @public
  */
@@ -455,6 +541,33 @@ NODES: "text";
 export { defineText }
 export { defineText as defineText_alias_1 }
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleTextInput}
+ */
+declare function defineTextInputHandler(handler: TextInputHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineTextInputHandler }
+export { defineTextInputHandler as defineTextInputHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleTripleClick}
+ */
+declare function defineTripleClickHandler(handler: TripleClickHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineTripleClickHandler }
+export { defineTripleClickHandler as defineTripleClickHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleTripleClickOn}
+ */
+declare function defineTripleClickOnHandler(handler: TripleClickOnHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineTripleClickOnHandler }
+export { defineTripleClickOnHandler as defineTripleClickOnHandler_alias_1 }
+
 /**
  * Registers a event handler that is called when the editor view is unmounted.
  *
@@ -485,6 +598,40 @@ declare type DocChangeHandler = (view: EditorView, prevState: EditorState) => vo
 export { DocChangeHandler }
 export { DocChangeHandler as DocChangeHandler_alias_1 }
 
+/**
+ * @internal
+ */
+export declare const domEventFacet: Facet<DOMEventPayload, PluginPayload>;
+
+/**
+ * A function to handle the events fired on the editable DOM element. Returns
+ * `true` to indicate that it handled the given event. you are responsible for
+ * calling `preventDefault` yourself (or not, if you want to allow the default
+ * behavior).
+ *
+ * @public
+ */
+declare type DOMEventHandler<Event extends keyof DOMEventMap = string> = (view: EditorView, event: DOMEventMap[Event]) => boolean | void;
+export { DOMEventHandler }
+export { DOMEventHandler as DOMEventHandler_alias_1 }
+
+/**
+ * @internal
+ */
+export declare type DOMEventPayload = [event: string, handler: DOMEventHandler];
+
+declare type DoubleClickHandler = (view: EditorView, pos: number, event: MouseEvent) => boolean | void;
+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;
+export { DoubleClickOnHandler }
+export { DoubleClickOnHandler as DoubleClickOnHandler_alias_1 }
+
+declare type DropHandler = (view: EditorView, event: DragEvent, slice: Slice, moved: boolean) => boolean | void;
+export { DropHandler }
+export { DropHandler as DropHandler_alias_1 }
+
 /**
  * @public
  */
@@ -585,6 +732,20 @@ declare type EmptyValue = undefined | null | EmptyObject;
 
 export declare type ExceptEmptyValue<T> = ConditionalExcept<T, EmptyValue>;
 
+/**
+ * Expands the selection to include the entire mark at the current position.
+ *
+ * @public
+ */
+declare function expandMark(options: {
+    /**
+     * The type of the mark to expand.
+     */
+    type: string | MarkType;
+}): Command;
+export { expandMark }
+export { expandMark as expandMark_alias_1 }
+
 /**
  * @public
  */
@@ -771,6 +932,12 @@ declare function getNodeType(schema: Schema, type: string | NodeType): NodeType;
 export { getNodeType }
 export { getNodeType as getNodeType_alias_1 }
 
+export declare type GroupedEntries<T extends Record<string, any>> = {
+    [K in keyof T]?: T[K][];
+};
+
+export declare function groupEntries<T extends Record<string, any>>(entries: ObjectEntries<T>[]): GroupedEntries<T>;
+
 /**
  * Returns a command that inserts the given node at the current selection or at
  * the given position.
@@ -834,6 +1001,9 @@ declare function isMark(mark: unknown): mark is Mark;
 export { isMark }
 export { isMark as isMark_alias_1 }
 
+/**
+ * @internal
+ */
 export declare function isMarkActive(state: EditorState, type: string | MarkType, attrs?: Attrs | null): boolean;
 
 export declare function isNodeActive(state: EditorState, type: string | NodeType, attrs?: Attrs | null): boolean;
@@ -897,6 +1067,10 @@ declare function jsonFromState(state: EditorState): StateJSON;
 export { jsonFromState }
 export { jsonFromState as jsonFromState_alias_1 }
 
+declare type KeyDownHandler = (view: EditorView, event: KeyboardEvent) => boolean | void;
+export { KeyDownHandler }
+export { KeyDownHandler as KeyDownHandler_alias_1 }
+
 /**
  * @public
  */
@@ -920,6 +1094,10 @@ declare type KeymapPayload = Keymap;
 export { KeymapPayload }
 export { KeymapPayload as KeymapPayload_alias_1 }
 
+declare type KeyPressHandler = (view: EditorView, event: KeyboardEvent) => boolean | void;
+export { KeyPressHandler }
+export { KeyPressHandler as KeyPressHandler_alias_1 }
+
 /**
  * @public
  */
@@ -1097,8 +1275,27 @@ declare const OBJECT_REPLACEMENT_CHARACTER = "\uFFFC";
 export { OBJECT_REPLACEMENT_CHARACTER }
 export { OBJECT_REPLACEMENT_CHARACTER as OBJECT_REPLACEMENT_CHARACTER_alias_1 }
 
+/**
+ * @internal
+ *
+ * @example
+ *
+ * ```
+ * type MyObject = { a: 1; b: 'B' }
+ * type MyEntries = ObjectEntries<MyObject>
+ * //   ^ ["a", 1] | ["b", "B"]
+ *
+ */
+export declare type ObjectEntries<T extends Record<string, any>> = {
+    [K in keyof T]: [K, T[K]];
+}[keyof T];
+
 export declare function objectEqual<T>(a: T, b: T): boolean;
 
+declare type PasteHandler = (view: EditorView, event: ClipboardEvent, slice: Slice) => boolean | void;
+export { PasteHandler }
+export { PasteHandler as PasteHandler_alias_1 }
+
 declare type Payload = unknown;
 
 export declare type Payloads = PayloadTuple[];
@@ -1176,6 +1373,10 @@ export declare const schemaFacet: Facet<SchemaPayload, SchemaPayload>;
 
 export declare type SchemaPayload = SchemaSpec;
 
+declare type ScrollToSelectionHandler = (view: EditorView) => boolean;
+export { ScrollToSelectionHandler }
+export { ScrollToSelectionHandler as ScrollToSelectionHandler_alias_1 }
+
 /**
  * Returns a command that selects the whole document.
  *
@@ -1238,6 +1439,11 @@ export { setNodeAttrs as setNodeAttrs_alias_1 }
 
 export declare function setSelectionAround(tr: Transaction, pos: number): void;
 
+/**
+ * @internal
+ */
+export declare type Setter<T> = (value: T) => void;
+
 /**
  * @internal
  */
@@ -1289,6 +1495,10 @@ export declare type StatePayload = (ctx: {
     schema: Schema;
 }) => EditorStateConfig;
 
+declare type TextInputHandler = (view: EditorView, from: number, to: number, text: string) => boolean | void;
+export { TextInputHandler }
+export { TextInputHandler as TextInputHandler_alias_1 }
+
 export declare type ToCommandApplier<T extends CommandArgs> = {
     [K in keyof T]: CommandApplier<T[K]>;
 };
@@ -1326,6 +1536,14 @@ declare function toggleNode({ type, attrs, }: {
 export { toggleNode }
 export { toggleNode as toggleNode_alias_1 }
 
+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;
+export { TripleClickOnHandler }
+export { TripleClickOnHandler as TripleClickOnHandler_alias_1 }
+
 declare type Tuple5<T> = [T, T, T, T, T];
 
 /**

package/dist/prosekit-core.d.ts

@@ -1,4 +1,5 @@
 export { addMark } from './_tsup-dts-rollup';
+export { expandMark } from './_tsup-dts-rollup';
 export { insertNode } from './_tsup-dts-rollup';
 export { removeMark } from './_tsup-dts-rollup';
 export { setBlockType } from './_tsup-dts-rollup';
@@ -10,8 +11,8 @@ export { createEditor } from './_tsup-dts-rollup';
 export { EditorOptions } from './_tsup-dts-rollup';
 export { union } from './_tsup-dts-rollup';
 export { withPriority } from './_tsup-dts-rollup';
-export { ProseKitError_alias_1 as ProseKitError } from './_tsup-dts-rollup';
 export { EditorNotFoundError_alias_1 as EditorNotFoundError } from './_tsup-dts-rollup';
+export { ProseKitError_alias_1 as ProseKitError } from './_tsup-dts-rollup';
 export { defineBaseCommands } from './_tsup-dts-rollup';
 export { defineCommands } from './_tsup-dts-rollup';
 export { defineDefaultState } from './_tsup-dts-rollup';
@@ -19,6 +20,32 @@ export { DefaultStateOptions } from './_tsup-dts-rollup';
 export { defineDoc } from './_tsup-dts-rollup';
 export { defineDocChangeHandler } from './_tsup-dts-rollup';
 export { DocChangeHandler } from './_tsup-dts-rollup';
+export { defineDOMEventHandler } from './_tsup-dts-rollup';
+export { DOMEventHandler } from './_tsup-dts-rollup';
+export { defineClickHandler } from './_tsup-dts-rollup';
+export { defineClickOnHandler } from './_tsup-dts-rollup';
+export { defineDoubleClickHandler } from './_tsup-dts-rollup';
+export { defineDoubleClickOnHandler } from './_tsup-dts-rollup';
+export { defineDropHandler } from './_tsup-dts-rollup';
+export { defineKeyDownHandler } from './_tsup-dts-rollup';
+export { defineKeyPressHandler } from './_tsup-dts-rollup';
+export { definePasteHandler } from './_tsup-dts-rollup';
+export { defineScrollToSelectionHandler } from './_tsup-dts-rollup';
+export { defineTextInputHandler } from './_tsup-dts-rollup';
+export { defineTripleClickHandler } from './_tsup-dts-rollup';
+export { defineTripleClickOnHandler } from './_tsup-dts-rollup';
+export { ClickHandler } from './_tsup-dts-rollup';
+export { ClickOnHandler } from './_tsup-dts-rollup';
+export { DoubleClickHandler } from './_tsup-dts-rollup';
+export { DoubleClickOnHandler } from './_tsup-dts-rollup';
+export { DropHandler } from './_tsup-dts-rollup';
+export { KeyDownHandler } from './_tsup-dts-rollup';
+export { KeyPressHandler } from './_tsup-dts-rollup';
+export { PasteHandler } from './_tsup-dts-rollup';
+export { ScrollToSelectionHandler } from './_tsup-dts-rollup';
+export { TextInputHandler } from './_tsup-dts-rollup';
+export { TripleClickHandler } from './_tsup-dts-rollup';
+export { TripleClickOnHandler } from './_tsup-dts-rollup';
 export { defineFocusChangeHandler } from './_tsup-dts-rollup';
 export { FocusChangeHandler } from './_tsup-dts-rollup';
 export { defineMountHandler } from './_tsup-dts-rollup';
@@ -28,7 +55,6 @@ 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 { defineInputRule } from './_tsup-dts-rollup';
 export { defineBaseKeymap } from './_tsup-dts-rollup';
 export { defineKeymap } from './_tsup-dts-rollup';
 export { keymapFacet } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -43,6 +43,59 @@ function addMark(options) {
   };
 }
 
+// src/commands/expand-mark.ts
+import { TextSelection } from "@prosekit/pm/state";
+function expandMark(options) {
+  return (state, dispatch) => {
+    const markType = getMarkType(state.schema, options.type);
+    const predicate = (mark) => mark.type === markType;
+    const from = expandMarkBefore(state.selection.$from, predicate);
+    const to = expandMarkAfter(state.selection.$to, predicate);
+    if (from === state.selection.from && to === state.selection.to) {
+      return false;
+    }
+    if (dispatch) {
+      dispatch(state.tr.setSelection(TextSelection.create(state.doc, from, to)));
+    }
+    return true;
+  };
+}
+function expandMarkBefore($pos, predicate) {
+  const { parent } = $pos;
+  if (!$pos.marks().some(predicate)) {
+    return $pos.pos;
+  }
+  const index = $pos.index();
+  let boundaryIndex = index;
+  for (let i = index; i >= 0; i--) {
+    const node = parent.child(i);
+    if (node.marks.some(predicate)) {
+      boundaryIndex = i;
+    } else {
+      break;
+    }
+  }
+  return $pos.posAtIndex(boundaryIndex);
+}
+function expandMarkAfter($pos, predicate) {
+  const { parent } = $pos;
+  if (!$pos.marks().some(predicate)) {
+    return $pos.pos;
+  }
+  const index = Math.max(0, $pos.indexAfter() - 1);
+  const childCount = parent.childCount;
+  let boundaryIndex = index;
+  for (let i = index; i < childCount; i++) {
+    const node = parent.child(i);
+    if (node.marks.some(predicate)) {
+      boundaryIndex = i;
+    } else {
+      break;
+    }
+  }
+  return $pos.posAtIndex(boundaryIndex) + parent.child(boundaryIndex).nodeSize;
+}
+
 // src/commands/insert-node.ts
 import "@prosekit/pm/state";
 import { insertPoint } from "@prosekit/pm/transform";
@@ -61,11 +114,11 @@ function getNodeType(schema, type) {
 }
 
 // src/utils/set-selection-around.ts
-import { TextSelection } from "@prosekit/pm/state";
+import { TextSelection as TextSelection2 } from "@prosekit/pm/state";
 function setSelectionAround(tr, pos) {
   const docSize = tr.doc.content.size;
   const $pos = tr.doc.resolve(pos > docSize ? docSize : pos < 0 ? 0 : pos);
-  const selection = TextSelection.between($pos, $pos);
+  const selection = TextSelection2.between($pos, $pos);
   tr.setSelection(selection);
 }
 
@@ -115,13 +168,13 @@ function removeMark(options) {
 import "@prosekit/pm/state";
 
 // src/utils/get-custom-selection.ts
-import { TextSelection as TextSelection2 } from "@prosekit/pm/state";
+import { TextSelection as TextSelection3 } from "@prosekit/pm/state";
 function getCustomSelection(state, from, to) {
   const pos = from != null ? from : to;
   if (pos != null) {
     const $from = state.doc.resolve(from != null ? from : pos);
     const $to = state.doc.resolve(to != null ? to : pos);
-    return TextSelection2.between($from, $to);
+    return TextSelection3.between($from, $to);
   }
   return state.selection;
 }
@@ -696,12 +749,25 @@ function updateExtension(prevInputs, prevConverters, extension, mode) {
 // src/editor/builder.ts
 import "@prosekit/pm/model";
 
+// src/utils/is-mark-active.ts
+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());
+  } else {
+    const markOrType = attrs ? markType.create(attrs) : markType;
+    return state.doc.rangeHasMark(from, to, markOrType);
+  }
+}
+
 // src/utils/type-assertion.ts
 import { Mark, ProseMirrorNode } from "@prosekit/pm/model";
 import {
   AllSelection,
   NodeSelection,
-  TextSelection as TextSelection3
+  TextSelection as TextSelection4
 } from "@prosekit/pm/state";
 function isProseMirrorNode(node) {
   return node instanceof ProseMirrorNode;
@@ -710,7 +776,7 @@ function isMark(mark) {
   return mark instanceof Mark;
 }
 function isTextSelection(sel) {
-  return sel instanceof TextSelection3;
+  return sel instanceof TextSelection4;
 }
 function isNodeSelection(sel) {
   return sel instanceof NodeSelection;
@@ -719,28 +785,6 @@ function isAllSelection(sel) {
   return sel instanceof AllSelection;
 }
 
-// src/utils/is-mark-active.ts
-function isMarkActive(state, type, attrs) {
-  const markType = getMarkType(state.schema, type);
-  const mark = attrs ? markType.create(attrs) : markType;
-  const { from, $from, to, empty } = state.selection;
-  if (empty) {
-    return hasMark(state.storedMarks || $from.marks(), mark);
-  } else {
-    return state.doc.rangeHasMark(from, to, mark);
-  }
-}
-function hasMark(marks, mark) {
-  if (marks.length === 0) {
-    return false;
-  }
-  if (isMark(mark)) {
-    return marks.some((m) => m.eq(mark));
-  } else {
-    return marks.some((m) => m.type === mark);
-  }
-}
-
 // src/editor/builder.ts
 function createNodeBuilder(getState, type) {
   const builder = (...args) => buildNode(type, args);
@@ -1398,26 +1442,201 @@ function defineDocChangeHandler(handler) {
   });
 }
 
-// src/extensions/events/focus.ts
+// src/extensions/events/dom-event.ts
 import { PluginKey as PluginKey2, ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm/state";
-function defineFocusChangeHandler(handler) {
-  const handleFocus = () => handler(true);
-  const handleBlur = () => handler(false);
-  const plugin = new ProseMirrorPlugin2({
-    key: new PluginKey2("prosekit-focus-handler"),
-    view: (view) => {
-      const dom = view.dom;
-      dom.addEventListener("focus", handleFocus);
-      dom.addEventListener("blur", handleBlur);
-      return {
-        destroy: () => {
-          dom.removeEventListener("focus", handleFocus);
-          dom.removeEventListener("blur", handleBlur);
+
+// src/utils/combine-event-handlers.ts
+function combineEventHandlers() {
+  let _handlers = [];
+  function setHandlers(handlers) {
+    _handlers = handlers;
+  }
+  function combinedEventHandler(...args) {
+    for (const handler of _handlers) {
+      if (handler(...args)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  return [setHandlers, combinedEventHandler];
+}
+
+// src/utils/group-entries.ts
+function groupEntries(entries) {
+  const map = {};
+  for (const [key, value] of entries) {
+    const values = map[key];
+    if (!values) {
+      map[key] = [value];
+    } else {
+      values.push(value);
+    }
+  }
+  return map;
+}
+
+// src/extensions/events/dom-event.ts
+function defineDOMEventHandler(event, handler) {
+  return domEventFacet.extension([
+    [event, handler]
+  ]);
+}
+var domEventFacet = Facet.define({
+  converter: () => {
+    const setHandlersMap = {};
+    const combinedHandlerMap = {};
+    const update = (payloads) => {
+      let hasNewEvent = false;
+      for (const [event] of payloads) {
+        if (!setHandlersMap[event]) {
+          hasNewEvent = true;
+          const [setHandlers, combinedHandler] = combineEventHandlers();
+          setHandlersMap[event] = setHandlers;
+          combinedHandlerMap[event] = combinedHandler;
         }
-      };
+      }
+      const map = groupEntries(payloads);
+      for (const [event, handlers] of Object.entries(map)) {
+        const setHandlers = setHandlersMap[event];
+        setHandlers(handlers != null ? handlers : []);
+      }
+      if (hasNewEvent) {
+        return new ProseMirrorPlugin2({
+          key: new PluginKey2("prosekit-dom-event-handler"),
+          props: { handleDOMEvents: combinedHandlerMap }
+        });
+      } else {
+        return null;
+      }
+    };
+    return {
+      create: (payloads) => {
+        const plugin = update(payloads);
+        return plugin ? () => plugin : () => [];
+      },
+      update: (payloads) => {
+        const plugin = update(payloads);
+        return plugin ? () => plugin : null;
+      }
+    };
+  },
+  next: pluginFacet,
+  singleton: true
+});
+
+// src/extensions/events/editor-event.ts
+import { PluginKey as PluginKey3, ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
+function defineKeyDownHandler(handler) {
+  return editorEventFacet.extension([["keyDown", handler]]);
+}
+function defineKeyPressHandler(handler) {
+  return editorEventFacet.extension([["keyPress", handler]]);
+}
+function defineTextInputHandler(handler) {
+  return editorEventFacet.extension([["textInput", handler]]);
+}
+function defineClickOnHandler(handler) {
+  return editorEventFacet.extension([["clickOn", handler]]);
+}
+function defineClickHandler(handler) {
+  return editorEventFacet.extension([["click", handler]]);
+}
+function defineDoubleClickOnHandler(handler) {
+  return editorEventFacet.extension([["doubleClickOn", handler]]);
+}
+function defineDoubleClickHandler(handler) {
+  return editorEventFacet.extension([["doubleClick", handler]]);
+}
+function defineTripleClickOnHandler(handler) {
+  return editorEventFacet.extension([["tripleClickOn", handler]]);
+}
+function defineTripleClickHandler(handler) {
+  return editorEventFacet.extension([["tripleClick", handler]]);
+}
+function definePasteHandler(handler) {
+  return editorEventFacet.extension([["paste", handler]]);
+}
+function defineDropHandler(handler) {
+  return editorEventFacet.extension([["drop", handler]]);
+}
+function defineScrollToSelectionHandler(handler) {
+  return editorEventFacet.extension([["scrollToSelection", handler]]);
+}
+var editorEventFacet = Facet.define({
+  converter: () => {
+    const [update, plugin] = setupEditorEventPlugin();
+    return {
+      create: (entries) => {
+        update(entries);
+        return () => plugin;
+      },
+      update: (entries) => {
+        update(entries);
+        return null;
+      }
+    };
+  },
+  next: pluginFacet,
+  singleton: true
+});
+function setupEditorEventPlugin() {
+  const [setKeyDownHandlers, handleKeyDown] = combineEventHandlers();
+  const [setKeyPressHandlers, handleKeyPress] = combineEventHandlers();
+  const [setTextInputHandlers, handleTextInput] = combineEventHandlers();
+  const [setClickOnHandlers, handleClickOn] = combineEventHandlers();
+  const [setClickHandlers, handleClick] = combineEventHandlers();
+  const [setDoubleClickOnHandlers, handleDoubleClickOn] = combineEventHandlers();
+  const [setDoubleClickHandlers, handleDoubleClick] = combineEventHandlers();
+  const [setTripleClickOnHandlers, handleTripleClickOn] = combineEventHandlers();
+  const [setTripleClickHandlers, handleTripleClick] = combineEventHandlers();
+  const [setPasteHandlers, handlePaste] = combineEventHandlers();
+  const [setDropHandlers, handleDrop] = combineEventHandlers();
+  const [setScrollToSelectionHandlers, handleScrollToSelection] = combineEventHandlers();
+  const update = (entries) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    const map = groupEntries(entries);
+    setKeyDownHandlers((_a = map.keyDown) != null ? _a : []);
+    setKeyPressHandlers((_b = map.keyPress) != null ? _b : []);
+    setTextInputHandlers((_c = map.textInput) != null ? _c : []);
+    setClickOnHandlers((_d = map.clickOn) != null ? _d : []);
+    setClickHandlers((_e = map.click) != null ? _e : []);
+    setDoubleClickOnHandlers((_f = map.doubleClickOn) != null ? _f : []);
+    setDoubleClickHandlers((_g = map.doubleClick) != null ? _g : []);
+    setTripleClickOnHandlers((_h = map.tripleClickOn) != null ? _h : []);
+    setTripleClickHandlers((_i = map.tripleClick) != null ? _i : []);
+    setPasteHandlers((_j = map.paste) != null ? _j : []);
+    setDropHandlers((_k = map.drop) != null ? _k : []);
+    setScrollToSelectionHandlers((_l = map.scrollToSelection) != null ? _l : []);
+  };
+  const plugin = new ProseMirrorPlugin3({
+    key: new PluginKey3("prosekit-editor-handler"),
+    props: {
+      handleKeyDown,
+      handleKeyPress,
+      handleTextInput,
+      handleClickOn,
+      handleClick,
+      handleDoubleClickOn,
+      handleDoubleClick,
+      handleTripleClickOn,
+      handleTripleClick,
+      handlePaste,
+      handleDrop,
+      handleScrollToSelection
     }
   });
-  return definePlugin(plugin);
+  return [update, plugin];
+}
+
+// src/extensions/events/focus.ts
+function defineFocusChangeHandler(handler) {
+  const handleFocus = () => handler(true);
+  const handleBlur = () => handler(false);
+  return domEventFacet.extension([
+    ["focus", handleFocus],
+    ["blur", handleBlur]
+  ]);
 }
 
 // src/extensions/history.ts
@@ -1429,7 +1648,7 @@ var isMac = typeof navigator !== "undefined" ? /Mac|iP(hone|[ao]d)/.test(navigat
 // src/extensions/keymap.ts
 import { baseKeymap, chainCommands } from "@prosekit/pm/commands";
 import { keydownHandler } from "@prosekit/pm/keymap";
-import { Plugin as Plugin3, PluginKey as PluginKey3 } from "@prosekit/pm/state";
+import { Plugin as Plugin3, PluginKey as PluginKey4 } from "@prosekit/pm/state";
 function defineKeymap(keymap) {
   return keymapFacet.extension([keymap]);
 }
@@ -1480,7 +1699,7 @@ function mergeKeymaps(keymaps) {
     ])
   );
 }
-var keymapPluginKey = new PluginKey3("prosekit-keymap");
+var keymapPluginKey = new PluginKey4("prosekit-keymap");
 
 // src/extensions/history.ts
 function defineHistory() {
@@ -1501,32 +1720,6 @@ function defineHistory() {
   ]);
 }
 
-// src/extensions/input-rules.ts
-import { InputRule, inputRules } from "@prosekit/pm/inputrules";
-import "@prosekit/pm/model";
-import "@prosekit/pm/state";
-function defineInputRule(rule) {
-  if (rule instanceof InputRule) {
-    return inputRuleFacet.extension([() => rule]);
-  }
-  if (Array.isArray(rule) && rule.every((r) => r instanceof InputRule)) {
-    return inputRuleFacet.extension([() => rule]);
-  }
-  if (typeof rule === "function") {
-    return inputRuleFacet.extension([rule]);
-  }
-  throw new TypeError("Invalid input rule");
-}
-var inputRuleFacet = Facet.define({
-  convert: (inputs) => {
-    return (context) => {
-      const rules = inputs.flatMap((callback) => callback(context));
-      return [inputRules({ rules })];
-    };
-  },
-  next: pluginFacet
-});
-
 // src/extensions/mark-spec.ts
 function defineMarkSpec(options) {
   const payload = [options, void 0];
@@ -1619,7 +1812,7 @@ var markSpecFacet = Facet.define({
 });
 
 // src/extensions/node-view.ts
-import { ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
+import { ProseMirrorPlugin as ProseMirrorPlugin4 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
 function defineNodeView(options) {
   return nodeViewFacet.extension([options]);
@@ -1632,13 +1825,13 @@ var nodeViewFacet = Facet.define({
         nodeViews[input.name] = input.constructor;
       }
     }
-    return () => [new ProseMirrorPlugin3({ props: { nodeViews } })];
+    return () => [new ProseMirrorPlugin4({ props: { nodeViews } })];
   },
   next: pluginFacet
 });
 
 // src/extensions/node-view-effect.ts
-import { ProseMirrorPlugin as ProseMirrorPlugin4 } from "@prosekit/pm/state";
+import { ProseMirrorPlugin as ProseMirrorPlugin5 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
 function defineNodeViewFactory(options) {
   return nodeViewFactoryFacet.extension([options]);
@@ -1666,7 +1859,7 @@ var nodeViewFactoryFacet = Facet.define({
         nodeViews[name] = factory(args);
       }
     }
-    return () => [new ProseMirrorPlugin4({ props: { nodeViews } })];
+    return () => [new ProseMirrorPlugin5({ props: { nodeViews } })];
   },
   next: pluginFacet
 });
@@ -1750,13 +1943,20 @@ export {
   defaultBlockAt,
   defineBaseCommands,
   defineBaseKeymap,
+  defineClickHandler,
+  defineClickOnHandler,
   defineCommands,
+  defineDOMEventHandler,
   defineDefaultState,
   defineDoc,
   defineDocChangeHandler,
+  defineDoubleClickHandler,
+  defineDoubleClickOnHandler,
+  defineDropHandler,
   defineFocusChangeHandler,
   defineHistory,
-  defineInputRule,
+  defineKeyDownHandler,
+  defineKeyPressHandler,
   defineKeymap,
   defineMarkAttr,
   defineMarkSpec,
@@ -1766,10 +1966,16 @@ export {
   defineNodeView,
   defineNodeViewFactory,
   defineParagraph,
+  definePasteHandler,
   definePlugin,
+  defineScrollToSelectionHandler,
   defineText,
+  defineTextInputHandler,
+  defineTripleClickHandler,
+  defineTripleClickOnHandler,
   defineUnmountHandler,
   defineUpdateHandler,
+  expandMark,
   getMarkType,
   getNodeType,
   insertNode,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.2.7",
+  "version": "0.3.1",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -38,13 +38,13 @@
     "@prosekit/pm": "^0.1.1",
     "clsx": "^2.1.0",
     "orderedmap": "^2.1.1",
-    "type-fest": "^4.10.1"
+    "type-fest": "^4.10.2"
   },
   "devDependencies": {
     "@prosekit/dev": "*",
-    "tsup": "^8.0.1",
+    "tsup": "^8.0.2",
     "typescript": "^5.3.3",
-    "vitest": "^1.2.1"
+    "vitest": "^1.2.2"
   },
   "scripts": {
     "build:tsup": "tsup",