@prosekit/core 0.3.0 → 0.3.2

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

@@ -5,6 +5,7 @@ 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';
@@ -15,6 +16,7 @@ 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';
@@ -30,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';
@@ -122,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.
  *
@@ -135,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;
@@ -281,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]>;
@@ -311,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.
  *
@@ -332,6 +399,15 @@ redo: [];
 export { defineHistory }
 export { defineHistory as defineHistory_alias_1 }
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleKeyDown}
+ */
+declare function defineKeyDownHandler(handler: KeyDownHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineKeyDownHandler }
+export { defineKeyDownHandler as defineKeyDownHandler_alias_1 }
+
 /**
  * @public
  */
@@ -339,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
  */
@@ -415,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.
  *
@@ -429,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
  */
@@ -438,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.
  *
@@ -468,6 +598,49 @@ declare type DocChangeHandler = (view: EditorView, prevState: EditorState) => vo
 export { DocChangeHandler }
 export { DocChangeHandler as DocChangeHandler_alias_1 }
 
+/**
+ * @internal
+ */
+export declare class DOMDocumentNotFoundError extends ProseKitError {
+    constructor();
+}
+
+/**
+ * @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];
+
+export declare type DOMNode = InstanceType<typeof window.Node>;
+
+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
  */
@@ -562,7 +735,31 @@ export { EditorOptions as EditorOptions_alias_1 }
  *
  * @internal
  */
-export declare function elementFromHTML(html: string): HTMLElement;
+export declare function elementFromHTML(html: string, options?: {
+    document?: Document;
+}): HTMLElement;
+
+/**
+ * Parse a ProseMirror document JSON object to a HTML element.
+ *
+ * @public
+ */
+declare function elementFromJSON(json: NodeJSON, schema: Schema, options?: {
+    document?: Document;
+}): HTMLElement;
+export { elementFromJSON }
+export { elementFromJSON as elementFromJSON_alias_1 }
+
+/**
+ * Serialize a ProseMirror node to a HTML element.
+ *
+ * @public
+ */
+declare function elementFromNode(node: ProseMirrorNode, options?: {
+    document?: Document;
+}): HTMLElement;
+export { elementFromNode }
+export { elementFromNode as elementFromNode_alias_1 }
 
 declare type EmptyValue = undefined | null | EmptyObject;
 
@@ -726,6 +923,14 @@ declare interface FacetOptions<Input, Output> {
 export { FacetOptions }
 export { FacetOptions as FacetOptions_alias_1 }
 
+export declare function findBrowserDocument(options?: {
+    document?: Document;
+}): Document | undefined;
+
+export declare function findBrowserWindow(options?: {
+    document?: Document;
+}): (Window & typeof globalThis) | null | undefined;
+
 /**
  * A function that is called when the editor gains or loses focus.
  *
@@ -737,9 +942,13 @@ declare type FocusChangeHandler = (hasFocus: boolean) => void;
 export { FocusChangeHandler }
 export { FocusChangeHandler as FocusChangeHandler_alias_1 }
 
-export declare function getBrowserDocument(): Document | undefined;
+export declare function getBrowserDocument(options?: {
+    document?: Document;
+}): Document;
 
-export declare function getBrowserWindow(): (Window & typeof globalThis) | null | undefined;
+export declare function getBrowserWindow(options?: {
+    document?: Document;
+}): Window & typeof globalThis;
 
 export declare function getCustomSelection(state: EditorState, from?: number | null, to?: number | null): Selection_3;
 
@@ -768,6 +977,37 @@ 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>;
+
+/**
+ * @internal
+ */
+export declare function htmlFromElement(element: HTMLElement): string;
+
+/**
+ * Parse a ProseMirror document JSON object to a HTML string.
+ *
+ * @public
+ */
+declare function htmlFromJSON(json: NodeJSON, schema: Schema, options?: {
+    document?: Document;
+}): string;
+export { htmlFromJSON }
+export { htmlFromJSON as htmlFromJSON_alias_1 }
+
+/**
+ * Serialize a ProseMirror node to a HTML string
+ *
+ * @public
+ */
+declare function htmlFromNode(node: ProseMirrorNode): string;
+export { htmlFromNode }
+export { htmlFromNode as htmlFromNode_alias_1 }
+
 /**
  * Returns a command that inserts the given node at the current selection or at
  * the given position.
@@ -862,20 +1102,20 @@ export { isTextSelection }
 export { isTextSelection as isTextSelection_alias_1 }
 
 /**
- * Parse a HTML element to a ProseMirror document JSON.
+ * Serialize a HTML element to a ProseMirror document JSON object.
  *
  * @public
  */
-declare function jsonFromElement(element: HTMLElement, schema: Schema): NodeJSON;
-export { jsonFromElement }
-export { jsonFromElement as jsonFromElement_alias_1 }
+export declare function jsonFromElement(element: DOMNode, schema: Schema): NodeJSON;
 
 /**
- * Parse a HTML string to a ProseMirror document JSON.
+ * Parse a HTML string to a ProseMirror document JSON object.
  *
  * @public
  */
-declare function jsonFromHTML(html: string, schema: Schema): NodeJSON;
+declare function jsonFromHTML(html: string, schema: Schema, options?: {
+    document?: Document;
+}): NodeJSON;
 export { jsonFromHTML }
 export { jsonFromHTML as jsonFromHTML_alias_1 }
 
@@ -897,6 +1137,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 +1164,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
  */
@@ -1021,7 +1269,7 @@ export declare type NodeContent = ProseMirrorNode | ProseMirrorFragment | NodeCo
  *
  * @public
  */
-declare function nodeFromElement(element: HTMLElement, schema: Schema): ProseMirrorNode;
+declare function nodeFromElement(element: DOMNode, schema: Schema): ProseMirrorNode;
 export { nodeFromElement }
 export { nodeFromElement as nodeFromElement_alias_1 }
 
@@ -1030,7 +1278,9 @@ export { nodeFromElement as nodeFromElement_alias_1 }
  *
  * @public
  */
-declare function nodeFromHTML(html: string, schema: Schema): ProseMirrorNode;
+declare function nodeFromHTML(html: string, schema: Schema, options?: {
+    document?: Document;
+}): ProseMirrorNode;
 export { nodeFromHTML }
 export { nodeFromHTML as nodeFromHTML_alias_1 }
 
@@ -1097,8 +1347,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 +1445,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 +1511,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 +1567,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 +1608,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

@@ -20,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';
@@ -73,7 +99,10 @@ export { _getId } from './_tsup-dts-rollup';
 export { getMarkType } from './_tsup-dts-rollup';
 export { getNodeType } from './_tsup-dts-rollup';
 export { isInCodeBlock } from './_tsup-dts-rollup';
-export { jsonFromElement } from './_tsup-dts-rollup';
+export { elementFromJSON } from './_tsup-dts-rollup';
+export { elementFromNode } from './_tsup-dts-rollup';
+export { htmlFromJSON } from './_tsup-dts-rollup';
+export { htmlFromNode } from './_tsup-dts-rollup';
 export { jsonFromHTML } from './_tsup-dts-rollup';
 export { jsonFromNode } from './_tsup-dts-rollup';
 export { jsonFromState } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -15,6 +15,13 @@ var EditorNotFoundError = class extends ProseKitError {
     );
   }
 };
+var DOMDocumentNotFoundError = class extends ProseKitError {
+  constructor() {
+    super(
+      "Unable to find browser Document. When not in the browser environment, you need to pass a DOM Document."
+    );
+  }
+};
 
 // src/utils/get-mark-type.ts
 function getMarkType(schema, type) {
@@ -433,11 +440,11 @@ var stateFacet = Facet.defineRootFacet({
 });
 
 // src/utils/parse.ts
-import { DOMParser } from "@prosekit/pm/model";
+import { DOMParser, DOMSerializer } from "@prosekit/pm/model";
 import { EditorState } from "@prosekit/pm/state";
 
 // src/utils/get-dom-api.ts
-function getGlobalBrowserDocument() {
+function findGlobalBrowserDocument() {
   if (typeof document !== "undefined") {
     return document;
   }
@@ -445,7 +452,7 @@ function getGlobalBrowserDocument() {
     return globalThis.document;
   }
 }
-function getGlobalBrowserWindow() {
+function findGlobalBrowserWindow() {
   if (typeof window !== "undefined") {
     return window;
   }
@@ -453,49 +460,78 @@ function getGlobalBrowserWindow() {
     return globalThis.window;
   }
 }
-function getBrowserWindow() {
-  var _a;
-  const win = getGlobalBrowserWindow();
-  if (win) {
+function findBrowserDocument(options) {
+  var _a, _b, _c;
+  return (_c = (_a = options == null ? void 0 : options.document) != null ? _a : findGlobalBrowserDocument()) != null ? _c : (_b = findGlobalBrowserWindow()) == null ? void 0 : _b.document;
+}
+function findBrowserWindow(options) {
+  var _a, _b, _c, _d;
+  return (_d = (_b = (_a = options == null ? void 0 : options.document) == null ? void 0 : _a.defaultView) != null ? _b : findGlobalBrowserWindow()) != null ? _d : (_c = findBrowserDocument(options)) == null ? void 0 : _c.defaultView;
+}
+function getBrowserDocument(options) {
+  const doc = findBrowserDocument(options);
+  if (doc)
+    return doc;
+  throw new DOMDocumentNotFoundError();
+}
+function getBrowserWindow(options) {
+  const win = findBrowserWindow(options);
+  if (win)
     return win;
-  }
-  return (_a = getGlobalBrowserDocument()) == null ? void 0 : _a.defaultView;
+  throw new DOMDocumentNotFoundError();
 }
 
 // src/utils/parse.ts
-function nodeFromElement(element, schema) {
-  return DOMParser.fromSchema(schema).parse(element);
+function jsonFromState(state) {
+  return state.toJSON();
 }
-function jsonFromElement(element, schema) {
-  return jsonFromNode(nodeFromElement(element, schema));
+function stateFromJSON(json, schema) {
+  return EditorState.fromJSON({ schema }, json);
 }
-function nodeFromHTML(html, schema) {
-  return nodeFromElement(elementFromHTML(html), schema);
+function jsonFromNode(node) {
+  return node.toJSON();
+}
+function nodeFromJSON(json, schema) {
+  return schema.nodeFromJSON(json);
 }
-function jsonFromHTML(html, schema) {
-  return jsonFromElement(elementFromHTML(html), schema);
+function nodeFromElement(element, schema) {
+  return DOMParser.fromSchema(schema).parse(element);
 }
-function elementFromHTML(html) {
-  const win = getBrowserWindow();
-  if (!win) {
-    throw new ProseKitError(
-      "No Browser Document Found. You can only parse a HTML string in the browser environment."
-    );
+function elementFromNode(node, options) {
+  const schema = node.type.schema;
+  const serializer = DOMSerializer.fromSchema(schema);
+  if (schema.topNodeType !== node.type) {
+    return serializer.serializeNode(node, options);
   }
+  const doc = getBrowserDocument();
+  const div = doc.createElement("div");
+  return serializer.serializeFragment(node.content, options, div);
+}
+function elementFromHTML(html, options) {
+  const win = getBrowserWindow(options);
   const parser = new win.DOMParser();
-  return parser.parseFromString(`<body>${html}</body>`, "text/html").body;
+  return parser.parseFromString(`<body><div>${html}</div></body>`, "text/html").body.firstElementChild;
 }
-function jsonFromState(state) {
-  return state.toJSON();
+function htmlFromElement(element) {
+  return element.outerHTML;
 }
-function jsonFromNode(node) {
-  return node.toJSON();
+function nodeFromHTML(html, schema, options) {
+  return nodeFromElement(elementFromHTML(html, options), schema);
 }
-function nodeFromJSON(json, schema) {
-  return schema.nodeFromJSON(json);
+function htmlFromNode(node) {
+  return elementFromNode(node).outerHTML;
 }
-function stateFromJSON(json, schema) {
-  return EditorState.fromJSON({ schema }, json);
+function jsonFromElement(element, schema) {
+  return jsonFromNode(nodeFromElement(element, schema));
+}
+function elementFromJSON(json, schema, options) {
+  return elementFromNode(nodeFromJSON(json, schema), options);
+}
+function jsonFromHTML(html, schema, options) {
+  return jsonFromElement(elementFromHTML(html, options), schema);
+}
+function htmlFromJSON(json, schema, options) {
+  return htmlFromElement(elementFromJSON(json, schema, options));
 }
 
 // src/extensions/default-state.ts
@@ -1442,21 +1478,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"),
-    props: {
-      handleDOMEvents: {
-        focus: handleFocus,
-        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
@@ -1468,7 +1684,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]);
 }
@@ -1519,7 +1735,7 @@ function mergeKeymaps(keymaps) {
     ])
   );
 }
-var keymapPluginKey = new PluginKey3("prosekit-keymap");
+var keymapPluginKey = new PluginKey4("prosekit-keymap");
 
 // src/extensions/history.ts
 function defineHistory() {
@@ -1632,7 +1848,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]);
@@ -1645,13 +1861,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]);
@@ -1679,7 +1895,7 @@ var nodeViewFactoryFacet = Facet.define({
         nodeViews[name] = factory(args);
       }
     }
-    return () => [new ProseMirrorPlugin4({ props: { nodeViews } })];
+    return () => [new ProseMirrorPlugin5({ props: { nodeViews } })];
   },
   next: pluginFacet
 });
@@ -1763,12 +1979,20 @@ export {
   defaultBlockAt,
   defineBaseCommands,
   defineBaseKeymap,
+  defineClickHandler,
+  defineClickOnHandler,
   defineCommands,
+  defineDOMEventHandler,
   defineDefaultState,
   defineDoc,
   defineDocChangeHandler,
+  defineDoubleClickHandler,
+  defineDoubleClickOnHandler,
+  defineDropHandler,
   defineFocusChangeHandler,
   defineHistory,
+  defineKeyDownHandler,
+  defineKeyPressHandler,
   defineKeymap,
   defineMarkAttr,
   defineMarkSpec,
@@ -1778,13 +2002,22 @@ export {
   defineNodeView,
   defineNodeViewFactory,
   defineParagraph,
+  definePasteHandler,
   definePlugin,
+  defineScrollToSelectionHandler,
   defineText,
+  defineTextInputHandler,
+  defineTripleClickHandler,
+  defineTripleClickOnHandler,
   defineUnmountHandler,
   defineUpdateHandler,
+  elementFromJSON,
+  elementFromNode,
   expandMark,
   getMarkType,
   getNodeType,
+  htmlFromJSON,
+  htmlFromNode,
   insertNode,
   isAllSelection,
   isInCodeBlock,
@@ -1792,7 +2025,6 @@ export {
   isNodeSelection,
   isProseMirrorNode,
   isTextSelection,
-  jsonFromElement,
   jsonFromHTML,
   jsonFromNode,
   jsonFromState,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -42,7 +42,7 @@
   },
   "devDependencies": {
     "@prosekit/dev": "*",
-    "tsup": "^8.0.1",
+    "tsup": "^8.0.2",
     "typescript": "^5.3.3",
     "vitest": "^1.2.2"
   },