@prosekit/core 0.0.0-next-20231120040948 → 0.0.0-next-20240421132240

package/dist/prosekit-core.js

@@ -8,6 +8,20 @@ import "@prosekit/pm/model";
 // src/error.ts
 var ProseKitError = class extends Error {
 };
+var EditorNotFoundError = class extends ProseKitError {
+  constructor() {
+    super(
+      "Unable to find editor. Pass it as an argument or call this function inside a ProseKit component."
+    );
+  }
+};
+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) {
@@ -36,8 +50,61 @@ function addMark(options) {
   };
 }
 
-// src/commands/insert-node.ts
+// 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";
 
 // src/utils/get-node-type.ts
@@ -53,6 +120,15 @@ function getNodeType(schema, type) {
   return type;
 }
 
+// src/utils/set-selection-around.ts
+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 = TextSelection2.between($pos, $pos);
+  tr.setSelection(selection);
+}
+
 // src/commands/insert-node.ts
 function insertNode(options) {
   return (state, dispatch) => {
@@ -70,7 +146,7 @@ function insertNode(options) {
       return false;
     if (dispatch) {
       const tr = state.tr.insert(insertPos, node);
-      tr.setSelection(TextSelection.near(tr.doc.resolve(insertPos)));
+      setSelectionAround(tr, insertPos + node.nodeSize);
       dispatch(tr);
     }
     return true;
@@ -99,13 +175,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;
 }
@@ -152,6 +228,29 @@ function setBlockType(options) {
   };
 }
 
+// src/commands/set-node-attrs.ts
+function setNodeAttrs(options) {
+  return (state, dispatch) => {
+    var _a;
+    const nodeType = getNodeType(state.schema, options.type);
+    const pos = (_a = options.pos) != null ? _a : state.selection.$from.before();
+    const node = state.doc.nodeAt(pos);
+    if (!node || node.type !== nodeType) {
+      return false;
+    }
+    if (dispatch) {
+      const { tr } = state;
+      for (const [key, value] of Object.entries(options.attrs)) {
+        if (value !== void 0) {
+          tr.setNodeAttribute(pos, key, value);
+        }
+      }
+      dispatch(tr);
+    }
+    return true;
+  };
+}
+
 // src/commands/toggle-mark.ts
 import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
 import "@prosekit/pm/model";
@@ -341,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;
   }
@@ -353,7 +452,7 @@ function getGlobalBrowserDocument() {
     return globalThis.document;
   }
 }
-function getGlobalBrowserWindow() {
+function findGlobalBrowserWindow() {
   if (typeof window !== "undefined") {
     return window;
   }
@@ -361,49 +460,85 @@ 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 jsonFromElement(element, schema) {
-  return jsonFromNode(nodeFromElement(element, schema));
+function jsonFromState(state) {
+  return state.toJSON();
 }
-function nodeFromHTML(html, schema) {
-  return nodeFromElement(elementFromHTML(html), schema);
+function stateFromJSON(json, options) {
+  return EditorState.fromJSON({ schema: options.schema }, json);
 }
-function jsonFromHTML(html, schema) {
-  return jsonFromElement(elementFromHTML(html), schema);
+function jsonFromNode(node) {
+  return node.toJSON();
 }
-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 nodeFromJSON(json, options) {
+  return options.schema.nodeFromJSON(json);
+}
+function nodeFromElement(element, options) {
+  const Parser = options.DOMParser || DOMParser;
+  const schema = options.schema;
+  return Parser.fromSchema(schema).parse(element);
+}
+function elementFromNode(node, options) {
+  const Serializer = (options == null ? void 0 : options.DOMSerializer) || DOMSerializer;
+  const document2 = getBrowserDocument(options);
+  const schema = node.type.schema;
+  const serializer = Serializer.fromSchema(schema);
+  if (schema.topNodeType !== node.type) {
+    return serializer.serializeNode(node, { document: document2 });
+  } else {
+    return serializer.serializeFragment(
+      node.content,
+      { document: document2 },
+      document2.createElement("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, options) {
+  return nodeFromElement(elementFromHTML(html, options), options);
+}
+function htmlFromNode(node, options) {
+  return elementFromNode(node, options).outerHTML;
+}
+function jsonFromElement(element, options) {
+  return jsonFromNode(nodeFromElement(element, options));
 }
-function nodeFromJSON(json, schema) {
-  return schema.nodeFromJSON(json);
+function elementFromJSON(json, options) {
+  return elementFromNode(nodeFromJSON(json, options), options);
 }
-function stateFromJSON(json, schema) {
-  return EditorState.fromJSON({ schema }, json);
+function jsonFromHTML(html, options) {
+  return jsonFromElement(elementFromHTML(html, options), options);
+}
+function htmlFromJSON(json, options) {
+  return htmlFromElement(elementFromJSON(json, options));
 }
 
 // src/extensions/default-state.ts
@@ -422,9 +557,9 @@ function defineDefaultState({
       const config = {};
       if (defaultHTML) {
         if (typeof defaultHTML === "string") {
-          defaultDoc = jsonFromHTML(defaultHTML, schema);
+          defaultDoc = jsonFromHTML(defaultHTML, { schema });
         } else {
-          defaultDoc = jsonFromElement(defaultHTML, schema);
+          defaultDoc = jsonFromElement(defaultHTML, { schema });
         }
       }
       if (defaultDoc) {
@@ -654,12 +789,28 @@ function updateExtension(prevInputs, prevConverters, extension, mode) {
   return { schemaInput, stateInput, viewInput, commandInput };
 }
 
+// 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;
@@ -668,7 +819,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;
@@ -677,30 +828,7 @@ 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
-import "@prosekit/pm/model";
 function createNodeBuilder(getState, type) {
   const builder = (...args) => buildNode(type, args);
   builder.isActive = (attrs) => {
@@ -814,12 +942,9 @@ function union(extension) {
 }
 
 // src/editor/editor.ts
-function createEditor({
-  extension,
-  defaultDoc,
-  defaultHTML,
-  defaultSelection
-}) {
+function createEditor(options) {
+  const { defaultDoc, defaultHTML, defaultSelection } = options;
+  let extension = options.extension;
   if (defaultDoc || defaultHTML) {
     extension = union([
       extension,
@@ -847,6 +972,7 @@ var EditorInstance = class {
     const schema = new Schema6(schemaInput);
     const stateConfig = stateInput ? stateInput({ schema }) : { schema };
     const state = EditorState2.create(stateConfig);
+    this.cachedState = state;
     if (commandInput) {
       for (const [name, commandCreator] of Object.entries(commandInput)) {
         this.defineCommand(name, commandCreator);
@@ -854,10 +980,7 @@ var EditorInstance = class {
     }
     this.directEditorProps = { state, ...viewInput };
     this.schema = this.directEditorProps.state.schema;
-    const getState = () => {
-      var _a;
-      return (_a = this.view) == null ? void 0 : _a.state;
-    };
+    const getState = () => this.getState();
     this.nodeBuilders = Object.fromEntries(
       Object.values(this.schema.nodes).map((type) => [
         type.name,
@@ -871,6 +994,12 @@ var EditorInstance = class {
       ])
     );
   }
+  getState() {
+    if (this.view) {
+      this.cachedState = this.view.state;
+    }
+    return this.cachedState;
+  }
   updateExtension(extension, mode) {
     var _a;
     const { schemaInput, stateInput, viewInput, commandInput } = updateExtension(this.payloads, this.converters, extension, mode);
@@ -975,18 +1104,38 @@ var Editor = class _Editor {
     }
     return new _Editor(instance);
   }
+  /**
+   * Whether the editor is mounted.
+   */
   get mounted() {
     return !!this.instance.view;
   }
+  /**
+   * The editor view.
+   */
   get view() {
     return this.instance.assertView;
   }
+  /**
+   * The editor schema.
+   */
   get schema() {
     return this.instance.schema;
   }
   get commands() {
     return this.instance.commandAppliers;
   }
+  /**
+   * Whether the editor is focused.
+   */
+  get focused() {
+    var _a, _b;
+    return (_b = (_a = this.instance.view) == null ? void 0 : _a.hasFocus()) != null ? _b : false;
+  }
+  /**
+   * Mount the editor to the given HTML element.
+   * Pass `null` or `undefined` to unmount the editor.
+   */
   mount(place) {
     if (!place) {
       return this.unmount();
@@ -994,11 +1143,28 @@ var Editor = class _Editor {
     this.instance.mount(place);
     this.afterMounted.forEach((callback) => callback());
   }
+  /**
+   * Unmount the editor. This is equivalent to `mount(null)`.
+   */
   unmount() {
     if (this.mounted) {
       this.instance.unmount();
     }
   }
+  /**
+   * Focus the editor.
+   */
+  focus() {
+    var _a;
+    (_a = this.instance.view) == null ? void 0 : _a.focus();
+  }
+  /**
+   * Blur the editor.
+   */
+  blur() {
+    var _a;
+    (_a = this.instance.view) == null ? void 0 : _a.dom.blur();
+  }
   use(extension) {
     if (!this.mounted) {
       let lazyRemove = null;
@@ -1013,17 +1179,8 @@ var Editor = class _Editor {
     this.instance.updateExtension(extension, "add");
     return () => this.instance.updateExtension(extension, "remove");
   }
-  /**
-   * @deprecated
-   */
-  isNodeActive(nodeType, attrs) {
-    return isNodeActive(this.view.state, nodeType, attrs);
-  }
-  /**
-   * @deprecated
-   */
-  isMarkActive(markType, attrs) {
-    return isMarkActive(this.view.state, markType, attrs);
+  get state() {
+    return this.instance.getState();
   }
   get nodes() {
     return this.instance.nodeBuilders;
@@ -1094,32 +1251,117 @@ function defineBaseCommands() {
     insertNode,
     wrap,
     setBlockType,
+    setNodeAttrs,
     selectAll,
     addMark,
     removeMark
   });
 }
 
+// src/utils/is-element.ts
+var hasElement = typeof Element !== "undefined";
+function isElement(value) {
+  return hasElement && value instanceof Element;
+}
+
+// src/utils/is-not-null.ts
+function isNotNull(value) {
+  return value != null;
+}
+
 // src/extensions/node-spec.ts
 function defineNodeSpec(options) {
-  return nodeSpecFacet.extension([options]);
+  const payload = [options, void 0];
+  return nodeSpecFacet.extension([payload]);
+}
+function defineNodeAttr(options) {
+  const payload = [void 0, options];
+  return nodeSpecFacet.extension([payload]);
 }
 var nodeSpecFacet = Facet.define({
-  convert: (options) => {
+  convert: (payloads) => {
     const nodes = {};
     let topNodeName = void 0;
-    for (const { name, topNode, ...spec } of options) {
+    const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
+    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
+    for (const { name, topNode, ...spec } of specPayloads) {
       if (nodes[name]) {
         throw new ProseKitError(`Node type ${name} has already been defined`);
       }
-      if (topNodeName && !topNode) {
+      if (topNode) {
         topNodeName = name;
       }
       nodes[name] = spec;
     }
+    for (const {
+      type,
+      attr,
+      default: defaultValue,
+      toDOM,
+      parseDOM
+    } of attrPayloads) {
+      const spec = nodes[type];
+      if (!spec) {
+        throw new ProseKitError(
+          `Node type ${type} must be defined before defining attributes`
+        );
+      }
+      if (!spec.attrs) {
+        spec.attrs = {};
+      }
+      spec.attrs[attr] = { default: defaultValue };
+      if (toDOM && spec.toDOM) {
+        const existingToDom = spec.toDOM;
+        spec.toDOM = (node) => {
+          const dom = existingToDom(node);
+          if (!dom) {
+            return dom;
+          }
+          const attrDOM = toDOM(node.attrs[attr]);
+          if (!attrDOM) {
+            return dom;
+          }
+          const [key, value] = attrDOM;
+          if (!key) {
+            return dom;
+          }
+          if (Array.isArray(dom)) {
+            if (typeof dom[1] === "object") {
+              return [dom[0], { ...dom[1], [key]: value }, ...dom.slice(2)];
+            } else {
+              return [dom[0], { [key]: value }, ...dom.slice(1)];
+            }
+          } else if (isElement(dom)) {
+            dom.setAttribute(key, value);
+          } else if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
+            dom.dom.setAttribute(key, value);
+          }
+          return dom;
+        };
+      }
+      if (parseDOM && spec.parseDOM) {
+        for (const rule of spec.parseDOM) {
+          const existingGetAttrs = rule.getAttrs;
+          const existingAttrs = rule.attrs;
+          rule.getAttrs = (dom) => {
+            var _a;
+            const attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
+            if (attrs === false || !dom || !isElement(dom)) {
+              return attrs != null ? attrs : null;
+            }
+            const value = parseDOM(dom);
+            return {
+              ...attrs,
+              [attr]: value
+            };
+          };
+        }
+      }
+    }
     return { nodes, topNode: topNodeName };
   },
-  next: schemaFacet
+  next: schemaFacet,
+  singleton: true
 });
 
 // src/extensions/doc.ts
@@ -1131,16 +1373,8 @@ function defineDoc() {
   });
 }
 
-// src/extensions/history.ts
-import { history, redo, undo } from "@prosekit/pm/history";
-
-// src/utils/env.ts
-var isMac = typeof navigator !== "undefined" ? /Mac|iP(hone|[ao]d)/.test(navigator.platform) : false;
-
-// src/extensions/keymap.ts
-import { baseKeymap, chainCommands } from "@prosekit/pm/commands";
-import { keydownHandler } from "@prosekit/pm/keymap";
-import { Plugin as Plugin3, PluginKey } from "@prosekit/pm/state";
+// src/extensions/events/plugin-view.ts
+import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
 
 // src/extensions/plugin.ts
 import "@prosekit/pm/model";
@@ -1158,21 +1392,313 @@ function definePlugin(plugin) {
   throw new TypeError("Invalid plugin");
 }
 var pluginFacet = Facet.define({
-  convert: (callbacks) => {
-    return ({ schema }) => {
-      const plugins = callbacks.flatMap((func) => func({ schema }));
+  converter: () => {
+    let inputs = [];
+    const output = ({ schema }) => {
+      const plugins = inputs.flatMap((func) => func({ schema }));
       return { plugins };
     };
+    return {
+      create: (payloads) => {
+        inputs = payloads;
+        return output;
+      },
+      update: (payloads) => {
+        inputs = payloads;
+        return output;
+      }
+    };
   },
   next: stateFacet
 });
 
+// src/extensions/events/plugin-view.ts
+function defineMountHandler(handler) {
+  return pluginViewFacet.extension([["mount", handler]]);
+}
+function defineUpdateHandler(handler) {
+  return pluginViewFacet.extension([["update", handler]]);
+}
+function defineUnmountHandler(handler) {
+  return pluginViewFacet.extension([["unmount", handler]]);
+}
+var pluginViewFacet = Facet.define({
+  converter: () => {
+    let mountHandlers = [];
+    let updateHandlers = [];
+    let unmountHandlers = [];
+    const plugin = new ProseMirrorPlugin({
+      key: pluginKey,
+      view: (view) => {
+        mountHandlers.forEach((fn) => fn(view));
+        return {
+          update: (view2, prevState) => {
+            updateHandlers.forEach((fn) => fn(view2, prevState));
+          },
+          destroy: () => {
+            unmountHandlers.forEach((fn) => fn());
+          }
+        };
+      }
+    });
+    const pluginFunc = () => [plugin];
+    const register = (input) => {
+      mountHandlers = [];
+      updateHandlers = [];
+      unmountHandlers = [];
+      for (const args of input) {
+        switch (args[0]) {
+          case "mount":
+            mountHandlers.push(args[1]);
+            break;
+          case "update":
+            updateHandlers.push(args[1]);
+            break;
+          case "unmount":
+            unmountHandlers.push(args[1]);
+            break;
+        }
+      }
+    };
+    return {
+      create: (input) => {
+        register(input);
+        return pluginFunc;
+      },
+      update: (input) => {
+        register(input);
+        return null;
+      }
+    };
+  },
+  next: pluginFacet,
+  singleton: true
+});
+var pluginKey = new PluginKey("prosekit-plugin-view-handler");
+
+// src/extensions/events/doc-change.ts
+function defineDocChangeHandler(handler) {
+  return defineUpdateHandler((view, prevState) => {
+    if (!view.state.doc.eq(prevState.doc)) {
+      handler(view, prevState);
+    }
+  });
+}
+
+// src/extensions/events/dom-event.ts
+import { PluginKey as PluginKey2, ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm/state";
+
+// 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 [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
+import { history, redo, undo } from "@prosekit/pm/history";
+
+// src/utils/env.ts
+var isMac = typeof navigator !== "undefined" ? /Mac|iP(hone|[ao]d)/.test(navigator.platform) : false;
+
 // src/extensions/keymap.ts
+import { baseKeymap, chainCommands } from "@prosekit/pm/commands";
+import { keydownHandler } from "@prosekit/pm/keymap";
+import { Plugin as Plugin3, PluginKey as PluginKey4 } from "@prosekit/pm/state";
 function defineKeymap(keymap) {
   return keymapFacet.extension([keymap]);
 }
-function defineBaseKeymap() {
-  return defineKeymap(baseKeymap);
+function defineBaseKeymap(options) {
+  var _a;
+  const priority = (_a = options == null ? void 0 : options.priority) != null ? _a : 3 /* low */;
+  return withPriority(defineKeymap(baseKeymap), priority);
 }
 var keymapFacet = Facet.define({
   converter: () => {
@@ -1216,7 +1742,7 @@ function mergeKeymaps(keymaps) {
     ])
   );
 }
-var keymapPluginKey = new PluginKey("prosekit-keymap");
+var keymapPluginKey = new PluginKey4("prosekit-keymap");
 
 // src/extensions/history.ts
 function defineHistory() {
@@ -1237,52 +1763,99 @@ 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) {
-  return markSpecFacet.extension([options]);
+  const payload = [options, void 0];
+  return markSpecFacet.extension([payload]);
+}
+function defineMarkAttr(options) {
+  const payload = [void 0, options];
+  return markSpecFacet.extension([payload]);
 }
 var markSpecFacet = Facet.define({
-  convert: (options) => {
+  convert: (payloads) => {
     const marks = {};
-    for (const { name, ...spec } of options) {
+    const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
+    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
+    for (const { name, ...spec } of specPayloads) {
       if (marks[name]) {
         throw new ProseKitError(`Mark type ${name} has already been defined`);
       }
       marks[name] = spec;
     }
+    for (const {
+      type,
+      attr,
+      default: defaultValue,
+      toDOM,
+      parseDOM
+    } of attrPayloads) {
+      const spec = marks[type];
+      if (!spec) {
+        throw new ProseKitError(
+          `Mark type ${type} must be defined before defining attributes`
+        );
+      }
+      if (!spec.attrs) {
+        spec.attrs = {};
+      }
+      spec.attrs[attr] = { default: defaultValue };
+      if (toDOM && spec.toDOM) {
+        const existingToDom = spec.toDOM;
+        spec.toDOM = (mark, inline) => {
+          const dom = existingToDom(mark, inline);
+          if (!dom) {
+            return dom;
+          }
+          const attrDOM = toDOM(mark.attrs[attr]);
+          if (!attrDOM) {
+            return dom;
+          }
+          const [key, value] = attrDOM;
+          if (!key) {
+            return dom;
+          }
+          if (Array.isArray(dom)) {
+            if (typeof dom[1] === "object") {
+              return [dom[0], { ...dom[1], [key]: value }, ...dom.slice(2)];
+            } else {
+              return [dom[0], { [key]: value }, ...dom.slice(1)];
+            }
+          } else if (isElement(dom)) {
+            dom.setAttribute(key, value);
+          } else if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
+            dom.dom.setAttribute(key, value);
+          }
+          return dom;
+        };
+      }
+      if (parseDOM && spec.parseDOM) {
+        for (const rule of spec.parseDOM) {
+          const existingGetAttrs = rule.getAttrs;
+          const existingAttrs = rule.attrs;
+          rule.getAttrs = (dom) => {
+            var _a;
+            const attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
+            if (attrs === false || !dom || !isElement(dom)) {
+              return attrs != null ? attrs : null;
+            }
+            const value = parseDOM(dom);
+            return {
+              ...attrs,
+              [attr]: value
+            };
+          };
+        }
+      }
+    }
     return { marks, nodes: {} };
   },
-  next: schemaFacet
+  next: schemaFacet,
+  singleton: true
 });
 
 // src/extensions/node-view.ts
-import { ProseMirrorPlugin } from "@prosekit/pm/state";
+import { ProseMirrorPlugin as ProseMirrorPlugin4 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
 function defineNodeView(options) {
   return nodeViewFacet.extension([options]);
@@ -1295,18 +1868,18 @@ var nodeViewFacet = Facet.define({
         nodeViews[input.name] = input.constructor;
       }
     }
-    return () => [new ProseMirrorPlugin({ props: { nodeViews } })];
+    return () => [new ProseMirrorPlugin4({ props: { nodeViews } })];
   },
   next: pluginFacet
 });
 
 // src/extensions/node-view-effect.ts
-import { ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm/state";
+import { ProseMirrorPlugin as ProseMirrorPlugin5 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
-function defineNodeViewEffect(options) {
-  return nodeViewEffectFacet.extension([options]);
+function defineNodeViewFactory(options) {
+  return nodeViewFactoryFacet.extension([options]);
 }
-var nodeViewEffectFacet = Facet.define({
+var nodeViewFactoryFacet = Facet.define({
   convert: (inputs) => {
     const nodeViews = {};
     const options = {};
@@ -1329,7 +1902,7 @@ var nodeViewEffectFacet = Facet.define({
         nodeViews[name] = factory(args);
       }
     }
-    return () => Object.keys(nodeViews).length > 0 ? [new ProseMirrorPlugin2({ props: { nodeViews } })] : [];
+    return () => [new ProseMirrorPlugin5({ props: { nodeViews } })];
   },
   next: pluginFacet
 });
@@ -1358,92 +1931,122 @@ function defineText() {
   });
 }
 
-// src/extensions/update-handler.ts
-import { PluginKey as PluginKey2, ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
+// src/utils/clsx.ts
+import clsxLite from "clsx/lite";
+var clsx = clsxLite;
 
-// src/utils/is-not-null.ts
-function isNotNull(value) {
-  return value != null;
+// src/utils/default-block-at.ts
+function defaultBlockAt(match) {
+  for (let i = 0; i < match.edgeCount; i++) {
+    const { type } = match.edge(i);
+    if (type.isTextblock && !type.hasRequiredAttrs())
+      return type;
+  }
+  return null;
 }
 
-// src/extensions/update-handler.ts
-function defineUpdateHandler(handler) {
-  return updateHandlerFacet.extension([handler]);
+// src/utils/get-id.ts
+var id = 0;
+function getId() {
+  id = (id + 1) % Number.MAX_SAFE_INTEGER;
+  return `id:${id}`;
+}
+
+// src/utils/is-in-code-block.ts
+function isCodeBlockType(type) {
+  return type.spec.code && type.isBlock;
+}
+function isInCodeBlock(selection) {
+  return isCodeBlockType(selection.$from.parent.type) || isCodeBlockType(selection.$to.parent.type);
+}
+
+// src/utils/unicode.ts
+var OBJECT_REPLACEMENT_CHARACTER = "\uFFFC";
+
+// src/utils/with-skip-code-block.ts
+function withSkipCodeBlock(command) {
+  return (state, dispatch, view) => {
+    if (isInCodeBlock(state.selection)) {
+      return false;
+    }
+    return command(state, dispatch, view);
+  };
 }
-var updateHandlerFacet = Facet.define({
-  converter: () => {
-    let updateHandlers = [];
-    const plugin = new ProseMirrorPlugin3({
-      key: pluginKey,
-      view: (view) => {
-        updateHandlers.forEach((fn) => fn({ view }));
-        return {
-          update: (view2, prevState) => {
-            updateHandlers.forEach((fn) => fn({ view: view2, prevState }));
-          }
-        };
-      }
-    });
-    const pluginFunc = () => [plugin];
-    return {
-      create: (handlers) => {
-        updateHandlers = handlers.filter(isNotNull);
-        return pluginFunc;
-      },
-      update: (handlers) => {
-        updateHandlers = handlers.filter(isNotNull);
-        return null;
-      }
-    };
-  },
-  next: pluginFacet,
-  singleton: true
-});
-var pluginKey = new PluginKey2("prosekit-event-handler");
 export {
   Editor,
+  EditorNotFoundError,
   Facet,
+  OBJECT_REPLACEMENT_CHARACTER,
   Priority,
   ProseKitError,
+  getId as _getId,
   addMark,
+  clsx,
   createEditor,
+  defaultBlockAt,
   defineBaseCommands,
   defineBaseKeymap,
+  defineClickHandler,
+  defineClickOnHandler,
   defineCommands,
+  defineDOMEventHandler,
   defineDefaultState,
   defineDoc,
+  defineDocChangeHandler,
+  defineDoubleClickHandler,
+  defineDoubleClickOnHandler,
+  defineDropHandler,
+  defineFocusChangeHandler,
   defineHistory,
-  defineInputRule,
+  defineKeyDownHandler,
+  defineKeyPressHandler,
   defineKeymap,
+  defineMarkAttr,
   defineMarkSpec,
+  defineMountHandler,
+  defineNodeAttr,
   defineNodeSpec,
   defineNodeView,
-  defineNodeViewEffect,
+  defineNodeViewFactory,
   defineParagraph,
+  definePasteHandler,
   definePlugin,
+  defineScrollToSelectionHandler,
   defineText,
+  defineTextInputHandler,
+  defineTripleClickHandler,
+  defineTripleClickOnHandler,
+  defineUnmountHandler,
   defineUpdateHandler,
+  elementFromJSON,
+  elementFromNode,
+  expandMark,
   getMarkType,
   getNodeType,
+  htmlFromJSON,
+  htmlFromNode,
   insertNode,
   isAllSelection,
+  isInCodeBlock,
   isMark,
   isNodeSelection,
   isProseMirrorNode,
   isTextSelection,
-  jsonFromElement,
   jsonFromHTML,
   jsonFromNode,
   jsonFromState,
+  keymapFacet,
   nodeFromElement,
   nodeFromHTML,
   nodeFromJSON,
   pluginFacet,
   removeMark,
   setBlockType,
+  setNodeAttrs,
   stateFromJSON,
   toggleMark,
   toggleNode,
   union,
-  withPriority
+  withPriority,
+  withSkipCodeBlock
 };