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

package/dist/prosekit-core.js

@@ -1,9 +1,27 @@
-// src/commands/toggle-mark.ts
-import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
+// src/commands/add-mark.ts
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+
+// src/utils/get-mark-type.ts
+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) {
@@ -17,134 +35,384 @@ function getMarkType(schema, type) {
   return type;
 }
 
-// src/commands/toggle-mark.ts
-function toggleMark(options) {
-  return (state, dispatch, view) => {
-    return baseToggleMark(
-      getMarkType(state.schema, options.type),
-      options.attrs
-    )(state, dispatch, view);
+// src/commands/add-mark.ts
+function addMark(options) {
+  return (state, dispatch) => {
+    var _a, _b;
+    const mark = getMarkType(state.schema, options.type).create(options.attrs);
+    const from = (_a = options.from) != null ? _a : state.selection.from;
+    const to = (_b = options.to) != null ? _b : state.selection.to;
+    if (from > to) {
+      return false;
+    }
+    dispatch == null ? void 0 : dispatch(state.tr.addMark(from, to, mark));
+    return true;
   };
 }
 
-// src/editor/editor.ts
-import { Schema } from "@prosekit/pm/model";
-import { EditorState } from "@prosekit/pm/state";
-import { EditorView } from "@prosekit/pm/view";
-
-// src/types/void-function.ts
-function voidFunction() {
+// 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;
+  };
 }
-
-// src/types/priority.ts
-var Priority = /* @__PURE__ */ ((Priority2) => {
-  Priority2[Priority2["lowest"] = 4] = "lowest";
-  Priority2[Priority2["low"] = 3] = "low";
-  Priority2[Priority2["default"] = 2] = "default";
-  Priority2[Priority2["high"] = 1] = "high";
-  Priority2[Priority2["highest"] = 0] = "highest";
-  return Priority2;
-})(Priority || {});
-
-// src/editor/facet.ts
-var nextIndex = 0;
-var Facet = class _Facet {
-  constructor(combine, next) {
-    /** @internal */
-    this.index = nextIndex++;
-    this.combine = combine;
-    this.next = next;
+function expandMarkBefore($pos, predicate) {
+  const { parent } = $pos;
+  if (!$pos.marks().some(predicate)) {
+    return $pos.pos;
   }
-  static define({ combine, next }) {
-    return new _Facet(combine, next);
+  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;
+    }
   }
-  /** @internal */
-  static defineSlot({
-    combine
-  }) {
-    return new _Facet(combine, null);
+  return $pos.posAtIndex(boundaryIndex);
+}
+function expandMarkAfter($pos, predicate) {
+  const { parent } = $pos;
+  if (!$pos.marks().some(predicate)) {
+    return $pos.pos;
   }
-  extension(inputs) {
-    return new FacetExtension(this, inputs);
+  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;
+    }
   }
-};
-var FacetExtension = class {
-  constructor(facet, inputs) {
-    this.facet = facet;
-    this.inputs = inputs;
+  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
+import "@prosekit/pm/model";
+function getNodeType(schema, type) {
+  if (typeof type === "string") {
+    const nodeType = schema.nodes[type];
+    if (!nodeType) {
+      throw new ProseKitError(`Cannot find ProseMirror node type "${type}"`);
+    }
+    return nodeType;
   }
-};
-function sortFacets(unsorted) {
-  var _a;
-  const facets = unsorted.filter((val) => val);
-  const facetMap = [];
-  const inbounds = [];
-  let facetCount = 0;
-  for (const facet of facets) {
-    const index = facet.index;
-    if (facetMap[index] != null) {
-      continue;
+  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) => {
+    var _a;
+    const node = options.node ? options.node : options.type ? getNodeType(state.schema, options.type).createChecked(options.attrs) : null;
+    if (!node) {
+      throw new ProseKitError("You must provide either a node or a type");
+    }
+    const insertPos = insertPoint(
+      state.doc,
+      (_a = options.pos) != null ? _a : state.selection.to,
+      node.type
+    );
+    if (insertPos == null)
+      return false;
+    if (dispatch) {
+      const tr = state.tr.insert(insertPos, node);
+      setSelectionAround(tr, insertPos + node.nodeSize);
+      dispatch(tr);
     }
-    if (inbounds[index] == null) {
-      inbounds[index] = 0;
+    return true;
+  };
+}
+
+// src/commands/remove-mark.ts
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+function removeMark(options) {
+  return (state, dispatch) => {
+    var _a, _b;
+    const markType = getMarkType(state.schema, options.type);
+    const mark = options.attrs ? markType.create(options.attrs) : markType;
+    const from = (_a = options.from) != null ? _a : state.selection.from;
+    const to = (_b = options.to) != null ? _b : state.selection.to;
+    if (from > to) {
+      return false;
     }
-    facetCount++;
-    facetMap[index] = facet;
-    if (facet.next) {
-      const nextIndex2 = facet.next.index;
-      if (inbounds[nextIndex2] == null) {
-        inbounds[nextIndex2] = 0;
+    dispatch == null ? void 0 : dispatch(state.tr.removeMark(from, to, mark));
+    return true;
+  };
+}
+
+// src/commands/set-block-type.ts
+import "@prosekit/pm/state";
+
+// src/utils/get-custom-selection.ts
+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 TextSelection3.between($from, $to);
+  }
+  return state.selection;
+}
+
+// src/commands/set-block-type.ts
+function setBlockType(options) {
+  return (state, dispatch) => {
+    const nodeType = getNodeType(state.schema, options.type);
+    const selection = getCustomSelection(state, options.from, options.to);
+    const attrs = options.attrs;
+    let applicable = false;
+    for (let i = 0; i < selection.ranges.length && !applicable; i++) {
+      const {
+        $from: { pos: from },
+        $to: { pos: to }
+      } = selection.ranges[i];
+      state.doc.nodesBetween(from, to, (node, pos) => {
+        if (applicable)
+          return false;
+        if (!node.isTextblock || node.hasMarkup(nodeType, attrs))
+          return;
+        if (node.type == nodeType) {
+          applicable = true;
+        } else {
+          const $pos = state.doc.resolve(pos), index = $pos.index();
+          applicable = $pos.parent.canReplaceWith(index, index + 1, nodeType);
+        }
+      });
+    }
+    if (!applicable)
+      return false;
+    if (dispatch) {
+      const tr = state.tr;
+      for (const range of selection.ranges) {
+        const {
+          $from: { pos: from },
+          $to: { pos: to }
+        } = range;
+        tr.setBlockType(from, to, nodeType, attrs);
       }
-      inbounds[nextIndex2] += 1;
-      if (facetMap[nextIndex2] == null) {
-        facets.push(facet.next);
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+}
+
+// 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";
+import "@prosekit/pm/state";
+function toggleMark({
+  type,
+  attrs
+}) {
+  return (state, dispatch, view) => {
+    return baseToggleMark(getMarkType(state.schema, type), attrs)(
+      state,
+      dispatch,
+      view
+    );
+  };
+}
+
+// src/commands/toggle-node.ts
+import { setBlockType as setBlockType2 } from "@prosekit/pm/commands";
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+
+// src/utils/attrs-match.ts
+function attrsMatch(nodeOrMark, attrs) {
+  const currentAttrs = nodeOrMark.attrs;
+  for (const [key, value] of Object.entries(attrs)) {
+    if (currentAttrs[key] !== value) {
+      return false;
     }
   }
-  const sortedFacets = [];
-  const sortedIndexes = [];
-  inbounds.forEach((inbound, index) => {
-    if (inbound === 0) {
-      sortedIndexes.push(index);
+  return true;
+}
+
+// src/utils/is-node-active.ts
+function isNodeActive(state, type, attrs) {
+  const $pos = state.selection.$from;
+  const nodeType = getNodeType(state.schema, type);
+  for (let depth = $pos.depth; depth >= 0; depth--) {
+    const node = $pos.node(depth);
+    if (node.type === nodeType && (!attrs || attrsMatch(node, attrs))) {
+      return true;
     }
-  });
-  for (const index of sortedIndexes) {
-    const facet = facetMap[index];
-    sortedFacets.push(facet);
-    const nextIndex2 = (_a = facet.next) == null ? void 0 : _a.index;
-    if (nextIndex2 == null)
-      continue;
-    inbounds[nextIndex2] -= 1;
-    if (inbounds[nextIndex2] === 0) {
-      sortedIndexes.push(nextIndex2);
+  }
+  return false;
+}
+
+// src/commands/toggle-node.ts
+function toggleNode({
+  type,
+  attrs
+}) {
+  return (state, dispatch, view) => {
+    if (isNodeActive(state, type, attrs)) {
+      const defaultType = state.schema.topNodeType.contentMatch.defaultType;
+      if (!defaultType) {
+        return false;
+      }
+      return setBlockType2(defaultType)(state, dispatch, view);
+    } else {
+      const nodeType = getNodeType(state.schema, type);
+      return setBlockType2(nodeType, attrs)(state, dispatch, view);
+    }
+  };
+}
+
+// src/editor/editor.ts
+import { Schema as Schema6 } from "@prosekit/pm/model";
+import { EditorState as EditorState2 } from "@prosekit/pm/state";
+import { EditorView } from "@prosekit/pm/view";
+
+// src/extensions/default-state.ts
+import { Selection } from "@prosekit/pm/state";
+
+// src/utils/uniq-array.ts
+function uniqPush(prev, next) {
+  const result = [...prev];
+  for (const item of next) {
+    if (!result.includes(item)) {
+      result.push(item);
     }
   }
-  if (facetCount !== sortedFacets.length) {
-    throw new Error(`Facet has circular dependency`);
+  return result;
+}
+function uniqRemove(prev, next) {
+  const result = [...prev];
+  for (const item of next) {
+    const index = result.indexOf(item);
+    if (index !== -1) {
+      result.splice(index, 1);
+    }
   }
-  return sortedFacets;
+  return result;
 }
 
-// src/editor/slot.ts
-import OrderedMap from "orderedmap";
-var schemaSlot = Facet.defineSlot({
-  combine: (specs) => {
-    var _a;
-    let nodes = OrderedMap.from({});
-    let marks = OrderedMap.from({});
-    let topNode = void 0;
-    for (const spec of specs) {
-      nodes = nodes.append(spec.nodes);
-      marks = marks.append((_a = spec.marks) != null ? _a : {});
-      topNode = topNode != null ? topNode : spec.topNode;
+// src/facets/base-extension.ts
+import "@prosekit/pm/model";
+var BaseExtension = class {
+  constructor() {
+    this.extension = [];
+  }
+};
+
+// src/facets/facet.ts
+var facetCount = 0;
+function getFacetCount() {
+  return facetCount;
+}
+var Facet = class _Facet {
+  constructor(converter, next, singleton) {
+    /**
+     * @internal
+     */
+    this.index = facetCount++;
+    /**
+     * @internal
+     */
+    this.isSchema = false;
+    this.converter = converter;
+    this.next = next;
+    this.singleton = singleton;
+  }
+  static define({
+    converter,
+    convert,
+    next,
+    singleton
+  }) {
+    const converterFunction = converter ? converter : convert ? () => ({
+      create: convert,
+      update: convert
+    }) : null;
+    if (!converterFunction) {
+      throw new ProseKitError("Facet must have either 'convert' or 'converter'");
     }
-    return { nodes, marks, topNode };
+    return new _Facet(converterFunction, next, singleton != null ? singleton : false);
   }
-});
-var stateSlot = Facet.defineSlot({
-  combine: (callbacks) => {
+  /**
+   * @internal
+   */
+  static defineRootFacet(options) {
+    return _Facet.define(options);
+  }
+  extension(payloads) {
+    return new FacetExtensionImpl(this, payloads);
+  }
+};
+var FacetExtensionImpl = class extends BaseExtension {
+  constructor(facet, payloads) {
+    var _a;
+    super();
+    this.facet = facet;
+    this.payloads = payloads;
+    this.schema = null;
+    this.hasSchema = !!(facet.isSchema || ((_a = facet.next) == null ? void 0 : _a.isSchema));
+  }
+};
+
+// src/facets/state.ts
+var stateFacet = Facet.defineRootFacet({
+  convert: (callbacks) => {
     return (ctx) => {
-      var _a, _b, _c, _d, _e;
+      var _a, _b, _c, _d, _e, _f;
       const configs = callbacks.map((cb) => cb(ctx));
       const config = {
         schema: ctx.schema,
@@ -156,10 +424,12 @@ var stateSlot = Facet.defineSlot({
         config.doc = (_b = config.doc) != null ? _b : c.doc;
         config.selection = (_c = config.selection) != null ? _c : c.selection;
         config.storedMarks = [...config.storedMarks, ...(_d = c.storedMarks) != null ? _d : []];
-        config.plugins = [...config.plugins, ...(_e = c.plugins) != null ? _e : []];
+        config.plugins = uniqPush((_e = config.plugins) != null ? _e : [], (_f = c.plugins) != null ? _f : []);
       }
       if (!config.doc && !config.schema) {
-        throw new Error("Can't create state without a schema nor a document");
+        throw new ProseKitError(
+          "Can't create state without a schema nor a document"
+        );
       }
       if (config.doc) {
         config.schema = void 0;
@@ -168,35 +438,240 @@ var stateSlot = Facet.defineSlot({
     };
   }
 });
-var viewSlot = Facet.defineSlot({
-  combine: (props) => {
-    return Object.assign({}, ...props);
+
+// src/utils/parse.ts
+import { DOMParser, DOMSerializer } from "@prosekit/pm/model";
+import { EditorState } from "@prosekit/pm/state";
+
+// src/utils/get-dom-api.ts
+function findGlobalBrowserDocument() {
+  if (typeof document !== "undefined") {
+    return document;
   }
-});
-var commandSlot = Facet.defineSlot({
-  combine: (inputs) => {
+  if (typeof globalThis !== "undefined" && globalThis.document) {
+    return globalThis.document;
+  }
+}
+function findGlobalBrowserWindow() {
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof globalThis !== "undefined" && globalThis.window) {
+    return globalThis.window;
+  }
+}
+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;
+  throw new DOMDocumentNotFoundError();
+}
+
+// src/utils/parse.ts
+function jsonFromState(state) {
+  return state.toJSON();
+}
+function stateFromJSON(json, options) {
+  return EditorState.fromJSON({ schema: options.schema }, json);
+}
+function jsonFromNode(node) {
+  return node.toJSON();
+}
+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><div>${html}</div></body>`, "text/html").body.firstElementChild;
+}
+function htmlFromElement(element) {
+  return element.outerHTML;
+}
+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 elementFromJSON(json, options) {
+  return elementFromNode(nodeFromJSON(json, options), options);
+}
+function jsonFromHTML(html, options) {
+  return jsonFromElement(elementFromHTML(html, options), options);
+}
+function htmlFromJSON(json, options) {
+  return htmlFromElement(elementFromJSON(json, options));
+}
+
+// src/extensions/default-state.ts
+function defineDefaultState({
+  defaultDoc,
+  defaultHTML,
+  defaultSelection
+}) {
+  if (defaultHTML && defaultDoc) {
+    throw new ProseKitError(
+      "Only one of defaultHTML and defaultDoc can be provided"
+    );
+  }
+  return stateFacet.extension([
+    ({ schema }) => {
+      const config = {};
+      if (defaultHTML) {
+        if (typeof defaultHTML === "string") {
+          defaultDoc = jsonFromHTML(defaultHTML, { schema });
+        } else {
+          defaultDoc = jsonFromElement(defaultHTML, { schema });
+        }
+      }
+      if (defaultDoc) {
+        config.doc = schema.nodeFromJSON(defaultDoc);
+        if (defaultSelection) {
+          config.selection = Selection.fromJSON(config.doc, defaultSelection);
+        }
+      }
+      return config;
+    }
+  ]);
+}
+
+// src/types/priority.ts
+var Priority = /* @__PURE__ */ ((Priority2) => {
+  Priority2[Priority2["lowest"] = 4] = "lowest";
+  Priority2[Priority2["low"] = 3] = "low";
+  Priority2[Priority2["default"] = 2] = "default";
+  Priority2[Priority2["high"] = 1] = "high";
+  Priority2[Priority2["highest"] = 0] = "highest";
+  return Priority2;
+})(Priority || {});
+
+// src/facets/command.ts
+var commandFacet = Facet.defineRootFacet({
+  convert: (inputs) => {
     return Object.assign({}, ...inputs);
   }
 });
 
-// src/editor/flatten.ts
-function flatten(root) {
+// src/facets/schema.ts
+import OrderedMap from "orderedmap";
+var schemaFacet = Facet.defineRootFacet({
+  convert: (specs) => {
+    var _a;
+    let nodes = OrderedMap.from({});
+    let marks = OrderedMap.from({});
+    let topNode = void 0;
+    for (const spec of specs) {
+      nodes = nodes.append(spec.nodes);
+      marks = marks.append((_a = spec.marks) != null ? _a : {});
+      topNode = topNode != null ? topNode : spec.topNode;
+    }
+    return { nodes, marks, topNode };
+  }
+});
+schemaFacet.isSchema = true;
+
+// src/facets/view.ts
+var viewFacet = Facet.defineRootFacet({
+  convert: (props) => {
+    return Object.assign({}, ...props);
+  }
+});
+
+// src/facets/flatten.ts
+function flattenInputTuple(inputTuple) {
+  return [
+    ...inputTuple[0],
+    ...inputTuple[1],
+    ...inputTuple[2],
+    ...inputTuple[3],
+    ...inputTuple[4]
+  ];
+}
+function mergeInputTuple(tupleA, tupleB) {
+  if (!tupleA)
+    return tupleB;
+  if (!tupleB)
+    return tupleA;
+  const [a0, a1, a2, a3, a4] = tupleA;
+  const [b0, b1, b2, b3, b4] = tupleB;
+  return [
+    uniqPush(a0, b0),
+    uniqPush(a1, b1),
+    uniqPush(a2, b2),
+    uniqPush(a3, b3),
+    uniqPush(a4, b4)
+  ];
+}
+function removeInputTuple(tupleA, tupleB) {
+  if (!tupleA)
+    return [[], [], [], [], []];
+  if (!tupleB)
+    return tupleA;
+  const [a0, a1, a2, a3, a4] = tupleA;
+  const [b0, b1, b2, b3, b4] = tupleB;
+  return [
+    uniqRemove(a0, b0),
+    uniqRemove(a1, b1),
+    uniqRemove(a2, b2),
+    uniqRemove(a3, b3),
+    uniqRemove(a4, b4)
+  ];
+}
+function extractFacets(root) {
   var _a;
   const extensions = [root];
   const priorities = [2 /* default */];
   const facets = [];
-  const inputs = [];
+  const payloads = [];
   while (extensions.length > 0) {
     const ext = extensions.pop();
     const pri = priorities.pop();
-    if (ext instanceof FacetExtension) {
+    if (ext instanceof FacetExtensionImpl) {
       const facet = ext.facet;
       if (!facets[facet.index]) {
         facets[facet.index] = facet;
-        inputs[facet.index] = [[], [], [], [], []];
+        payloads[facet.index] = [[], [], [], [], []];
       }
-      const facetInputs = ext.inputs;
-      inputs[facet.index][pri].push(...facetInputs);
+      const facetPayloads = ext.payloads;
+      payloads[facet.index][pri].push(...facetPayloads);
     } else if (ext.extension) {
       const p = (_a = ext.priority) != null ? _a : pri;
       if (Array.isArray(ext.extension)) {
@@ -209,103 +684,371 @@ function flatten(root) {
         priorities.push(p);
       }
     } else {
-      throw new Error("Invalid extension");
+      throw new ProseKitError("Invalid extension");
     }
   }
+  return [facets, payloads];
+}
+function updateExtension(prevInputs, prevConverters, extension, mode) {
+  var _a;
+  const modifyInputTuple = mode === "add" ? mergeInputTuple : removeInputTuple;
+  const [facets, inputs] = extractFacets(extension);
   let schemaInput = null;
   let stateInput = null;
   let viewInput = null;
   let commandInput = null;
-  const sortedFacets = sortFacets(facets);
-  for (const facet of sortedFacets) {
+  for (let index = getFacetCount(); index >= 0; index--) {
+    const facet = facets[index];
+    if (!facet) {
+      continue;
+    }
     const nextFacet = facet.next;
     if (nextFacet) {
+      facets[_a = nextFacet.index] || (facets[_a] = nextFacet);
+    }
+    if (!inputs[facet.index]) {
+      continue;
+    }
+    const inputTuple = modifyInputTuple(prevInputs[index], inputs[index]);
+    prevInputs[index] = inputTuple;
+    if (facet.next && !facet.singleton) {
+      let hasOutput = false;
+      const outputTuple = [[], [], [], [], []];
       for (let pri = 0; pri < 5; pri++) {
-        const input = inputs[facet.index][pri];
-        if (input.length > 0) {
-          const output = facet.combine(input);
-          if (!inputs[nextFacet.index]) {
-            inputs[nextFacet.index] = [[], [], [], [], []];
-          }
-          inputs[nextFacet.index][pri].push(output);
+        const inputArray = inputTuple[pri];
+        if (inputArray.length === 0) {
+          continue;
+        }
+        const converterTuple = prevConverters[index] || (prevConverters[index] = [
+          void 0,
+          void 0,
+          void 0,
+          void 0,
+          void 0
+        ]);
+        const prevConverter = converterTuple[pri];
+        const converter = prevConverter || facet.converter();
+        prevConverters[index][pri] = converter;
+        const output = prevConverter ? converter.update(inputArray) : converter.create(inputArray);
+        if (!output) {
+          continue;
         }
+        hasOutput = true;
+        outputTuple[pri].push(output);
       }
-    } else if (inputs[facet.index]) {
-      const [i1, i2, i3, i4, i5] = inputs[facet.index];
-      const jointInputs = [...i1, ...i2, ...i3, ...i4, ...i5];
-      const output = facet.combine(jointInputs);
-      switch (facet) {
-        case schemaSlot:
-          schemaInput = output;
-          break;
-        case stateSlot:
-          stateInput = output;
-          break;
-        case viewSlot:
-          viewInput = output;
-          break;
-        case commandSlot:
-          commandInput = output;
-          break;
-        default:
-          throw new Error("Invalid facet");
+      if (!hasOutput) {
+        continue;
+      }
+      inputs[facet.next.index] = modifyInputTuple(
+        inputs[facet.next.index],
+        outputTuple
+      );
+      continue;
+    } else {
+      const inputArray = flattenInputTuple(inputTuple);
+      prevConverters[index] || (prevConverters[index] = [
+        void 0,
+        void 0,
+        void 0,
+        void 0,
+        void 0
+      ]);
+      const prevConverter = prevConverters[index][2 /* default */];
+      const converter = prevConverter || facet.converter();
+      prevConverters[index][2 /* default */] = converter;
+      const output = prevConverter ? converter.update(inputArray) : converter.create(inputArray);
+      if (!output) {
+        continue;
+      }
+      if (facet.next) {
+        const outputTuple = [[], [], [output], [], []];
+        inputs[facet.next.index] = modifyInputTuple(
+          inputs[facet.next.index],
+          outputTuple
+        );
+      } else {
+        switch (facet) {
+          case schemaFacet:
+            schemaInput = output;
+            break;
+          case stateFacet:
+            stateInput = output;
+            break;
+          case viewFacet:
+            viewInput = output;
+            break;
+          case commandFacet:
+            commandInput = output;
+            break;
+          default:
+            throw new ProseKitError("Invalid root facet");
+        }
       }
     }
   }
   return { schemaInput, stateInput, viewInput, commandInput };
 }
 
-// src/editor/editor.ts
-function createEditor({
-  extension
-}) {
-  const { schemaInput, stateInput, viewInput, commandInput } = flatten(extension);
-  if (!schemaInput) {
-    throw new Error("Schema must be defined");
+// 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 TextSelection4
+} from "@prosekit/pm/state";
+function isProseMirrorNode(node) {
+  return node instanceof ProseMirrorNode;
+}
+function isMark(mark) {
+  return mark instanceof Mark;
+}
+function isTextSelection(sel) {
+  return sel instanceof TextSelection4;
+}
+function isNodeSelection(sel) {
+  return sel instanceof NodeSelection;
+}
+function isAllSelection(sel) {
+  return sel instanceof AllSelection;
+}
+
+// src/editor/builder.ts
+function createNodeBuilder(getState, type) {
+  const builder = (...args) => buildNode(type, args);
+  builder.isActive = (attrs) => {
+    const state = getState();
+    return state ? isNodeActive(state, type, attrs) : false;
+  };
+  return builder;
+}
+function createMarkBuilder(getState, type) {
+  const builder = (...args) => buildMark(type, args);
+  builder.isActive = (attrs) => {
+    const state = getState();
+    return state ? isMarkActive(state, type, attrs) : false;
+  };
+  return builder;
+}
+function buildMark(type, args) {
+  const [attrs, children] = normalizeArgs(args);
+  return flattenChildren(type.schema, children, type.create(attrs));
+}
+function buildNode(type, args) {
+  const [attrs, children] = normalizeArgs(args);
+  const node = type.createAndFill(attrs, flattenChildren(type.schema, children));
+  if (!node) {
+    throw new ProseKitError(`Couldn't create node ${type.name}`);
+  }
+  return node;
+}
+function flattenChildren(schema, children, mark) {
+  const nodes = [];
+  for (const child of children) {
+    if (typeof child === "string") {
+      if (child) {
+        nodes.push(schema.text(child, mark ? [mark] : null));
+      }
+    } else if (Array.isArray(child)) {
+      nodes.push(...flattenChildren(schema, child, mark));
+    } else if (isProseMirrorNode(child)) {
+      nodes.push(mark ? child.mark(mark.addToSet(child.marks)) : child);
+    } else {
+      throw new ProseKitError(`Invalid node child: ${typeof child}`);
+    }
+  }
+  return nodes;
+}
+function normalizeArgs(args) {
+  const [attrs, ...children] = args;
+  if (isNodeChild(attrs)) {
+    children.unshift(attrs);
+    return [null, children];
+  } else if (typeof attrs === "object") {
+    return [attrs, children];
+  } else {
+    return [null, children];
+  }
+}
+function isNodeChild(value) {
+  if (!value) {
+    return false;
+  }
+  return typeof value === "string" || Array.isArray(value) || isProseMirrorNode(value);
+}
+
+// src/facets/union-extension.ts
+import { Schema as Schema5 } from "@prosekit/pm/model";
+var UnionExtensionImpl = class extends BaseExtension {
+  constructor(extension = []) {
+    super();
+    this.extension = extension;
+    this._schema = void 0;
+    this.hasSchemaCount = 0;
+    for (const e of extension) {
+      if (e instanceof BaseExtension) {
+        this.hasSchemaCount += e.hasSchema ? 1 : 0;
+      } else {
+        throw new ProseKitError("Invalid extension");
+      }
+    }
   }
-  const schema = new Schema(schemaInput);
-  const stateConfig = stateInput ? stateInput({ schema }) : { schema };
-  const state = EditorState.create(stateConfig);
-  const directEditorProps = { state, ...viewInput };
-  const instance = new EditorInstance(directEditorProps);
-  if (commandInput) {
-    for (const [name, commandCreator] of Object.entries(commandInput)) {
-      instance.addCommand(name, commandCreator);
+  get hasSchema() {
+    return this.hasSchemaCount > 0;
+  }
+  get schema() {
+    var _a;
+    if (this._schema !== void 0) {
+      return this._schema;
+    }
+    if (this.hasSchemaCount === 0) {
+      this._schema = null;
+      return this._schema;
+    }
+    if (this.hasSchemaCount === 1) {
+      const schema = (_a = this.extension.find((e) => e.hasSchema)) == null ? void 0 : _a.schema;
+      if (schema) {
+        this._schema = schema;
+        return this._schema;
+      }
     }
+    const { schemaInput } = updateExtension([], [], this, "add");
+    this._schema = schemaInput ? new Schema5(schemaInput) : null;
+    return this._schema;
   }
-  return Editor.create(instance);
+};
+
+// src/editor/union.ts
+function union(extension) {
+  const array = Array.isArray(extension) ? extension : [extension];
+  return new UnionExtensionImpl(
+    array
+  );
+}
+
+// src/editor/editor.ts
+function createEditor(options) {
+  const { defaultDoc, defaultHTML, defaultSelection } = options;
+  let extension = options.extension;
+  if (defaultDoc || defaultHTML) {
+    extension = union([
+      extension,
+      defineDefaultState({
+        defaultDoc,
+        defaultHTML,
+        defaultSelection
+      })
+    ]);
+  }
+  return Editor.create(new EditorInstance(extension));
 }
 var EditorInstance = class {
-  constructor(directEditorProps) {
-    this.directEditorProps = directEditorProps;
+  constructor(extension) {
     this.view = null;
-    this.commandDispatchers = {};
+    this.commandAppliers = {};
+    this.payloads = [];
+    this.converters = [];
     this.mount = this.mount.bind(this);
     this.unmount = this.unmount.bind(this);
-    this.schema = directEditorProps.state.schema;
+    const { schemaInput, stateInput, viewInput, commandInput } = updateExtension(this.payloads, this.converters, extension, "add");
+    if (!schemaInput) {
+      throw new ProseKitError("Schema must be defined");
+    }
+    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);
+      }
+    }
+    this.directEditorProps = { state, ...viewInput };
+    this.schema = this.directEditorProps.state.schema;
+    const getState = () => this.getState();
+    this.nodeBuilders = Object.fromEntries(
+      Object.values(this.schema.nodes).map((type) => [
+        type.name,
+        createNodeBuilder(getState, type)
+      ])
+    );
+    this.markBuilders = Object.fromEntries(
+      Object.values(this.schema.marks).map((type) => [
+        type.name,
+        createMarkBuilder(getState, type)
+      ])
+    );
+  }
+  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);
+    if (schemaInput) {
+      throw new ProseKitError("Schema cannot be changed");
+    }
+    if (viewInput) {
+      throw new ProseKitError("View cannot be changed");
+    }
+    const plugins = (_a = stateInput == null ? void 0 : stateInput({ schema: this.schema })) == null ? void 0 : _a.plugins;
+    if (plugins && plugins.length > 0) {
+      if (!this.view) {
+        throw new ProseKitError(
+          "Unexpected inner state: EditorInstance.view is not defined"
+        );
+      }
+      const state = this.view.state.reconfigure({ plugins });
+      this.view.updateState(state);
+    }
+    if (commandInput) {
+      const names = Object.keys(commandInput);
+      for (const name of names) {
+        this.defineCommand(name, commandInput[name]);
+      }
+    }
   }
   mount(place) {
     if (this.view) {
-      throw new Error("Editor is already mounted");
+      throw new ProseKitError("Editor is already mounted");
     }
     if (!place) {
-      throw new Error("Can't mount editor without a place");
+      throw new ProseKitError("Can't mount editor without a place");
     }
     this.view = new EditorView({ mount: place }, this.directEditorProps);
   }
   unmount() {
     if (!this.view) {
-      throw new Error("Editor is not mounted yet");
+      throw new ProseKitError("Editor is not mounted yet");
     }
     this.view.destroy();
     this.view = null;
   }
   get assertView() {
-    if (!this.view)
-      throw new Error("Editor is not mounted");
+    if (!this.view) {
+      throw new ProseKitError("Editor is not mounted");
+    }
     return this.view;
   }
-  addPlugins(plugins) {
+  definePlugins(plugins) {
     const view = this.assertView;
     const state = view.state;
     const newPlugins = [...plugins, ...state.plugins];
@@ -321,16 +1064,27 @@ var EditorInstance = class {
     const newState = state.reconfigure({ plugins: newPlugins });
     view.setProps({ state: newState });
   }
-  addCommand(name, commandCreator) {
-    const dispatcher = (...args) => {
-      const view = this.assertView;
+  defineCommand(name, commandCreator) {
+    const applier = (...args) => {
+      const view = this.view;
+      if (!view) {
+        return false;
+      }
       const command = commandCreator(...args);
       return command(view.state, view.dispatch.bind(view), view);
     };
-    this.commandDispatchers[name] = dispatcher;
+    applier.canApply = (...args) => {
+      const view = this.view;
+      if (!view) {
+        return false;
+      }
+      const command = commandCreator(...args);
+      return command(view.state, void 0, view);
+    };
+    this.commandAppliers[name] = applier;
   }
   removeCommand(name) {
-    delete this.commandDispatchers[name];
+    delete this.commandAppliers[name];
   }
 };
 var Editor = class _Editor {
@@ -341,25 +1095,47 @@ var Editor = class _Editor {
     this.unmount = this.unmount.bind(this);
     this.use = this.use.bind(this);
   }
-  /** @internal */
+  /**
+   * @internal
+   */
   static create(instance) {
     if (!(instance instanceof EditorInstance)) {
-      throw new TypeError("Editor's instance is not EditorInstance");
+      throw new TypeError("Invalid EditorInstance");
     }
     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.commandDispatchers;
+    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();
@@ -367,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;
@@ -383,218 +1176,563 @@ var Editor = class _Editor {
         lazyRemove == null ? void 0 : lazyRemove();
       };
     }
-    const { schemaInput, stateInput, viewInput, commandInput } = flatten(extension);
-    if (schemaInput) {
-      throw new ProseKitError("Schema cannot be changed");
-    }
-    if (viewInput) {
-      throw new ProseKitError("View cannot be changed");
-    }
-    if (stateInput) {
-      const stateConfig = stateInput({ schema: this.schema });
-      const plugins = stateConfig.plugins;
-      if (plugins && plugins.length > 0) {
-        this.instance.addPlugins(plugins);
-        return () => this.instance.removePlugins(plugins);
-      }
-    }
-    if (commandInput) {
-      const names = Object.keys(commandInput);
-      for (const name of names) {
-        this.instance.addCommand(name, commandInput[name]);
-      }
-      return () => {
-        for (const name of names) {
-          this.instance.removeCommand(name);
-        }
-      };
-    }
-    return voidFunction;
+    this.instance.updateExtension(extension, "add");
+    return () => this.instance.updateExtension(extension, "remove");
   }
-};
-
-// src/editor/type-utils.ts
-function defineExtension(extension) {
-  if (extension && Array.isArray(extension)) {
-    return { extension };
+  get state() {
+    return this.instance.getState();
   }
-  return extension;
-}
+  get nodes() {
+    return this.instance.nodeBuilders;
+  }
+  get marks() {
+    return this.instance.markBuilders;
+  }
+};
 
 // src/editor/with-priority.ts
 function withPriority(extension, priority) {
-  return { extension, priority };
+  const result = union(extension);
+  result.priority = priority;
+  return result;
 }
 
-// src/extensions/command.ts
-import { AllSelection, Selection } from "@prosekit/pm/state";
-import { findWrapping, insertPoint } from "@prosekit/pm/transform";
-function addCommands(commands) {
-  return commandSlot.extension([commands]);
-}
-function addBaseCommands() {
-  return addCommands({
-    insertText: ({
-      text,
-      from,
-      to
-    }) => {
-      return (state, dispatch) => {
-        if (text) {
-          dispatch == null ? void 0 : dispatch(state.tr.insertText(text, from, to));
-        }
-        return true;
-      };
-    },
-    insertNode: ({ node, pos }) => {
-      return (state, dispatch) => {
-        const insertPos = insertPoint(
-          state.doc,
-          pos != null ? pos : state.selection.to,
-          node.type
-        );
-        if (insertPos == null)
-          return false;
-        if (dispatch) {
-          const tr = state.tr.insert(insertPos, node);
-          const $pos = tr.doc.resolve(insertPos);
-          tr.setSelection(Selection.near($pos));
-          dispatch(tr);
-        }
-        return true;
-      };
-    },
-    wrap: ({
-      nodeType,
-      attrs
-    }) => {
-      return (state, dispatch) => {
-        const { $from, $to } = state.selection;
-        const range = $from.blockRange($to);
-        if (!range)
-          return false;
-        const wrapping = findWrapping(range, nodeType, attrs);
-        if (!wrapping)
-          return false;
-        dispatch == null ? void 0 : dispatch(state.tr.wrap(range, wrapping));
-        return true;
-      };
-    },
-    setBlockType: ({
-      nodeType,
-      attrs,
-      from,
-      to
-    }) => {
-      return (state, dispatch) => {
-        from = from != null ? from : state.selection.from;
-        to = from != null ? from : state.selection.from;
-        dispatch == null ? void 0 : dispatch(state.tr.setBlockType(from, to, nodeType, attrs));
-        return true;
-      };
-    },
-    selectAll: () => {
-      return (state, dispatch) => {
-        dispatch == null ? void 0 : dispatch(state.tr.setSelection(new AllSelection(state.doc)));
-        return true;
-      };
+// src/commands/insert-text.ts
+function insertText({
+  text,
+  from,
+  to
+}) {
+  return (state, dispatch) => {
+    if (text) {
+      dispatch == null ? void 0 : dispatch(state.tr.insertText(text, from, to));
     }
+    return true;
+  };
+}
+
+// src/commands/select-all.ts
+import { AllSelection as AllSelection2 } from "@prosekit/pm/state";
+function selectAll() {
+  return (state, dispatch) => {
+    dispatch == null ? void 0 : dispatch(state.tr.setSelection(new AllSelection2(state.doc)));
+    return true;
+  };
+}
+
+// src/commands/wrap.ts
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+import { findWrapping } from "@prosekit/pm/transform";
+function wrap({
+  nodeType,
+  attrs
+}) {
+  return (state, dispatch) => {
+    const { $from, $to } = state.selection;
+    const range = $from.blockRange($to);
+    if (!range)
+      return false;
+    const wrapping = findWrapping(range, nodeType, attrs);
+    if (!wrapping)
+      return false;
+    dispatch == null ? void 0 : dispatch(state.tr.wrap(range, wrapping));
+    return true;
+  };
+}
+
+// src/extensions/command.ts
+function defineCommands(commands) {
+  return commandFacet.extension([commands]);
+}
+function defineBaseCommands() {
+  return defineCommands({
+    insertText,
+    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 addNodeSpec(options) {
-  return nodeSpecFacet.extension([options]);
+function defineNodeSpec(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({
-  combine: (options) => {
+  convert: (payloads) => {
     const nodes = {};
-    let topNode = void 0;
-    for (const { name, spec, topNode: isTopNode } of options) {
+    let topNodeName = void 0;
+    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 Error(`Node type ${name} has already been defined`);
+        throw new ProseKitError(`Node type ${name} has already been defined`);
+      }
+      if (topNode) {
+        topNodeName = name;
       }
       nodes[name] = spec;
-      if (isTopNode && !topNode) {
-        topNode = name;
+    }
+    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 };
+    return { nodes, topNode: topNodeName };
   },
-  next: schemaSlot
+  next: schemaFacet,
+  singleton: true
 });
 
 // src/extensions/doc.ts
-function addDoc() {
-  return addNodeSpec({
+function defineDoc() {
+  return defineNodeSpec({
     name: "doc",
-    spec: {
-      content: "block+"
-    }
+    content: "block+",
+    topNode: true
   });
 }
 
-// src/extensions/input-rules.ts
-import { inputRules } from "@prosekit/pm/inputrules";
+// src/extensions/events/plugin-view.ts
+import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
 
 // src/extensions/plugin.ts
-function addPlugin({ plugins }) {
-  if (typeof plugins === "function") {
-    return pluginFacet.extension([plugins]);
-  } else if (Array.isArray(plugins)) {
-    return pluginFacet.extension([() => plugins]);
-  } else {
-    throw new TypeError("plugins must be a function or an array");
+import "@prosekit/pm/model";
+import { Plugin as Plugin2 } from "@prosekit/pm/state";
+function definePlugin(plugin) {
+  if (plugin instanceof Plugin2) {
+    return pluginFacet.extension([() => [plugin]]);
+  }
+  if (Array.isArray(plugin) && plugin.every((p) => p instanceof Plugin2)) {
+    return pluginFacet.extension([() => plugin]);
+  }
+  if (typeof plugin === "function") {
+    return pluginFacet.extension([plugin]);
   }
+  throw new TypeError("Invalid plugin");
 }
 var pluginFacet = Facet.define({
-  combine: (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: stateSlot
+  next: stateFacet
 });
 
-// src/extensions/input-rules.ts
-function addInputRule(rules) {
-  return inputRuleFacet.extension([rules]);
+// 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 inputRuleFacet = Facet.define({
-  combine: (inputs) => {
-    return (context) => {
-      const rules = inputs.flatMap((callback) => callback(context));
-      return [inputRules({ rules })];
+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
+  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 { keymap as createKeymapPlugin } from "@prosekit/pm/keymap";
-function addKeymap(keymap) {
+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 addBaseKeymap() {
-  return addKeymap(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({
-  combine: (keymaps) => {
-    const keymap = mergeKeymaps(keymaps);
-    const plugin = createKeymapPlugin(keymap);
-    return () => [plugin];
+  converter: () => {
+    let handler = null;
+    const handlerWrapper = (view, event) => {
+      if (handler)
+        return handler(view, event);
+      return false;
+    };
+    const plugin = new Plugin3({
+      key: keymapPluginKey,
+      props: { handleKeyDown: handlerWrapper }
+    });
+    const pluginFunc = () => [plugin];
+    return {
+      create: (keymaps) => {
+        handler = keydownHandler(mergeKeymaps(keymaps));
+        return pluginFunc;
+      },
+      update: (keymaps) => {
+        handler = keydownHandler(mergeKeymaps(keymaps));
+        return null;
+      }
+    };
   },
-  next: pluginFacet
+  next: pluginFacet,
+  singleton: true
 });
 function mergeKeymaps(keymaps) {
   const bindings = {};
   for (const keymap of keymaps) {
     for (const [key, command] of Object.entries(keymap)) {
-      if (!bindings[key])
-        bindings[key] = [];
-      bindings[key].push(command);
+      const commands = bindings[key] || (bindings[key] = []);
+      commands.push(command);
     }
   }
   return Object.fromEntries(
@@ -604,101 +1742,311 @@ function mergeKeymaps(keymaps) {
     ])
   );
 }
+var keymapPluginKey = new PluginKey4("prosekit-keymap");
+
+// src/extensions/history.ts
+function defineHistory() {
+  const keymap = {
+    "Mod-z": undo,
+    "Shift-Mod-z": redo
+  };
+  if (!isMac) {
+    keymap["Mod-y"] = redo;
+  }
+  return union([
+    definePlugin(history()),
+    defineKeymap(keymap),
+    defineCommands({
+      undo: () => undo,
+      redo: () => redo
+    })
+  ]);
+}
 
 // src/extensions/mark-spec.ts
-function addMarkSpec(options) {
-  return markSpecFacet.extension([options]);
+function defineMarkSpec(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({
-  combine: (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 Error(`Mark type ${name} has already been defined`);
+        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: schemaSlot
+  next: schemaFacet,
+  singleton: true
 });
 
 // src/extensions/node-view.ts
-import { Plugin as Plugin2 } from "@prosekit/pm/state";
-function addNodeView(options) {
+import { ProseMirrorPlugin as ProseMirrorPlugin4 } from "@prosekit/pm/state";
+import "@prosekit/pm/view";
+function defineNodeView(options) {
   return nodeViewFacet.extension([options]);
 }
 var nodeViewFacet = Facet.define({
-  combine: (inputs) => {
+  convert: (inputs) => {
     const nodeViews = {};
     for (const input of inputs) {
       if (!nodeViews[input.name]) {
         nodeViews[input.name] = input.constructor;
       }
     }
-    return () => [new Plugin2({ props: { nodeViews } })];
+    return () => [new ProseMirrorPlugin4({ props: { nodeViews } })];
+  },
+  next: pluginFacet
+});
+
+// src/extensions/node-view-effect.ts
+import { ProseMirrorPlugin as ProseMirrorPlugin5 } from "@prosekit/pm/state";
+import "@prosekit/pm/view";
+function defineNodeViewFactory(options) {
+  return nodeViewFactoryFacet.extension([options]);
+}
+var nodeViewFactoryFacet = Facet.define({
+  convert: (inputs) => {
+    const nodeViews = {};
+    const options = {};
+    const factories = {};
+    for (const input of inputs) {
+      const group = input.group;
+      if (input.name == null) {
+        factories[group] = input.factory;
+      } else {
+        options[group] || (options[group] = []);
+        options[group].push({
+          name: input.name,
+          args: input.args
+        });
+      }
+    }
+    for (const [group, factory] of Object.entries(factories)) {
+      const groupOptions = options[group] || [];
+      for (const { name, args } of groupOptions) {
+        nodeViews[name] = factory(args);
+      }
+    }
+    return () => [new ProseMirrorPlugin5({ props: { nodeViews } })];
   },
   next: pluginFacet
 });
 
 // src/extensions/paragraph.ts
-function addParagraph() {
-  return addNodeSpec({
+function defineParagraphSpec() {
+  return defineNodeSpec({
     name: "paragraph",
-    spec: {
-      content: "inline*",
-      group: "block",
-      parseDOM: [{ tag: "p" }],
-      toDOM() {
-        return ["p", 0];
-      }
+    content: "inline*",
+    group: "block",
+    parseDOM: [{ tag: "p" }],
+    toDOM() {
+      return ["p", 0];
     }
   });
 }
+function defineParagraph() {
+  return withPriority(defineParagraphSpec(), 0 /* highest */);
+}
 
 // src/extensions/text.ts
-function addText() {
-  return addNodeSpec({
+function defineText() {
+  return defineNodeSpec({
     name: "text",
-    spec: {
-      group: "inline"
-    }
+    group: "inline"
   });
 }
 
-// src/utils/get-node-type.ts
-function getNodeType(schema, type) {
-  if (typeof type === "string") {
-    const nodeType = schema.nodes[type];
-    if (!nodeType) {
-      throw new ProseKitError(`Cannot find ProseMirror node type "${type}"`);
-    }
-    return nodeType;
+// src/utils/clsx.ts
+import clsxLite from "clsx/lite";
+var clsx = clsxLite;
+
+// 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 type;
+  return null;
+}
+
+// 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);
+  };
 }
 export {
   Editor,
+  EditorNotFoundError,
   Facet,
-  FacetExtension,
+  OBJECT_REPLACEMENT_CHARACTER,
   Priority,
   ProseKitError,
-  addBaseCommands,
-  addBaseKeymap,
-  addCommands,
-  addDoc,
-  addInputRule,
-  addKeymap,
-  addMarkSpec,
-  addNodeSpec,
-  addNodeView,
-  addParagraph,
-  addPlugin,
-  addText,
+  getId as _getId,
+  addMark,
+  clsx,
   createEditor,
-  defineExtension,
+  defaultBlockAt,
+  defineBaseCommands,
+  defineBaseKeymap,
+  defineClickHandler,
+  defineClickOnHandler,
+  defineCommands,
+  defineDOMEventHandler,
+  defineDefaultState,
+  defineDoc,
+  defineDocChangeHandler,
+  defineDoubleClickHandler,
+  defineDoubleClickOnHandler,
+  defineDropHandler,
+  defineFocusChangeHandler,
+  defineHistory,
+  defineKeyDownHandler,
+  defineKeyPressHandler,
+  defineKeymap,
+  defineMarkAttr,
+  defineMarkSpec,
+  defineMountHandler,
+  defineNodeAttr,
+  defineNodeSpec,
+  defineNodeView,
+  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,
+  jsonFromHTML,
+  jsonFromNode,
+  jsonFromState,
+  keymapFacet,
+  nodeFromElement,
+  nodeFromHTML,
+  nodeFromJSON,
+  pluginFacet,
+  removeMark,
+  setBlockType,
+  setNodeAttrs,
+  stateFromJSON,
   toggleMark,
-  withPriority
+  toggleNode,
+  union,
+  withPriority,
+  withSkipCodeBlock
 };