@prosekit/core 0.7.2 → 0.7.4

package/dist/prosekit-core.js

@@ -35,16 +35,21 @@ import {
   stateFromJSON,
   toReversed,
   union
-} from "./chunk-YWQGKV6X.js";
+} from "./chunk-52BNHWWJ.js";
 
 // src/commands/add-mark.ts
 import "@prosekit/pm/model";
-import "@prosekit/pm/state";
 function addMark(options) {
   return (state, dispatch) => {
     var _a, _b;
-    let mark = getMarkType(state.schema, options.type).create(options.attrs), from = (_a = options.from) != null ? _a : state.selection.from, to = (_b = options.to) != null ? _b : state.selection.to;
-    return from > to ? !1 : (dispatch == null || dispatch(state.tr.addMark(from, to, mark)), !0);
+    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;
   };
 }
 
@@ -52,37 +57,64 @@ function addMark(options) {
 import { TextSelection } from "@prosekit/pm/state";
 function expandMark(options) {
   return (state, dispatch) => {
-    let markType = getMarkType(state.schema, options.type), predicate = (mark) => mark.type === markType, from = expandMarkBefore(state.selection.$from, predicate), to = expandMarkAfter(state.selection.$to, predicate);
-    return from === state.selection.from && to === state.selection.to ? !1 : (dispatch && dispatch(state.tr.setSelection(TextSelection.create(state.doc, from, to))), !0);
+    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) {
-  let { parent } = $pos;
-  if (!$pos.marks().some(predicate))
+  const { parent } = $pos;
+  if (!$pos.marks().some(predicate)) {
     return $pos.pos;
-  let index = $pos.index(), boundaryIndex = index;
-  for (let i = index; i >= 0 && parent.child(i).marks.some(predicate); i--)
-    boundaryIndex = i;
+  }
+  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) {
-  let { parent } = $pos;
-  if (!$pos.marks().some(predicate))
+  const { parent } = $pos;
+  if (!$pos.marks().some(predicate)) {
     return $pos.pos;
-  let index = Math.max(0, $pos.indexAfter() - 1), childCount = parent.childCount, boundaryIndex = index;
-  for (let i = index; i < childCount && parent.child(i).marks.some(predicate); i++)
-    boundaryIndex = i;
+  }
+  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/set-selection-around.ts
 import { TextSelection as TextSelection2 } from "@prosekit/pm/state";
 function setSelectionAround(tr, pos) {
-  let docSize = tr.doc.content.size, $pos = tr.doc.resolve(pos > docSize ? docSize : pos < 0 ? 0 : pos), selection = TextSelection2.between($pos, $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);
 }
 
@@ -90,43 +122,53 @@ function setSelectionAround(tr, pos) {
 function insertNode(options) {
   return (state, dispatch) => {
     var _a;
-    let node = options.node ? options.node : options.type ? getNodeType(state.schema, options.type).createAndFill(options.attrs) : null;
+    const node = options.node ? options.node : options.type ? getNodeType(state.schema, options.type).createAndFill(options.attrs) : null;
     assert(node, "You must provide either a node or a type");
-    let insertPos = insertPoint(
+    const insertPos = insertPoint(
       state.doc,
       (_a = options.pos) != null ? _a : state.selection.anchor,
       node.type
     );
-    if (insertPos == null) return !1;
+    if (insertPos == null) return false;
     if (dispatch) {
-      let tr = state.tr.insert(insertPos, node);
-      setSelectionAround(tr, insertPos + node.nodeSize), dispatch(tr);
+      const tr = state.tr.insert(insertPos, node);
+      setSelectionAround(tr, insertPos + node.nodeSize);
+      dispatch(tr);
     }
-    return !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;
-    let markType = getMarkType(state.schema, options.type), mark = options.attrs ? markType.create(options.attrs) : markType, from = (_a = options.from) != null ? _a : state.selection.from, to = (_b = options.to) != null ? _b : state.selection.to;
-    return from > to ? !1 : (dispatch == null || dispatch(state.tr.removeMark(from, to, mark)), !0);
+    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;
+    }
+    dispatch == null ? void 0 : dispatch(state.tr.removeMark(from, to, mark));
+    return true;
   };
 }
 
 // src/utils/find-parent-node.ts
 function findParentNode(nodeType, $pos) {
-  for (let depth = $pos.depth; depth > 0; depth -= 1)
-    if ($pos.node(depth).type === nodeType) {
-      let from = $pos.before(depth), to = $pos.after(depth);
+  for (let depth = $pos.depth; depth > 0; depth -= 1) {
+    const node = $pos.node(depth);
+    if (node.type === nodeType) {
+      const from = $pos.before(depth);
+      const to = $pos.after(depth);
       return {
         from,
         to
       };
     }
+  }
   return {
     from: null,
     to: null
@@ -136,20 +178,24 @@ function findParentNode(nodeType, $pos) {
 // src/commands/remove-node.ts
 function removeNode(options) {
   return (state, dispatch) => {
-    let nodeType = getNodeType(state.schema, options.type), $pos = typeof options.pos == "number" ? state.doc.resolve(options.pos) : state.selection.$anchor, { from, to } = findParentNode(nodeType, $pos);
-    return from == null || to == null || from > to ? !1 : (dispatch == null || dispatch(state.tr.delete(from, to)), !0);
+    const nodeType = getNodeType(state.schema, options.type);
+    const $pos = typeof options.pos === "number" ? state.doc.resolve(options.pos) : state.selection.$anchor;
+    const { from, to } = findParentNode(nodeType, $pos);
+    if (from == null || to == null || from > to) {
+      return false;
+    }
+    dispatch == null ? void 0 : dispatch(state.tr.delete(from, to));
+    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) {
-  let pos = from != null ? from : to;
+  const pos = from != null ? from : to;
   if (pos != null) {
-    let $from = state.doc.resolve(from != null ? from : pos), $to = state.doc.resolve(to != null ? to : pos);
+    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;
@@ -158,28 +204,31 @@ function getCustomSelection(state, from, to) {
 // src/commands/set-block-type.ts
 function setBlockType(options) {
   return (state, dispatch) => {
-    let nodeType = getNodeType(state.schema, options.type), selection = getCustomSelection(state, options.from, options.to), attrs = options.attrs, applicable = !1;
+    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++) {
-      let {
+      const {
         $from: { pos: from },
         $to: { pos: to }
       } = selection.ranges[i];
       state.doc.nodesBetween(from, to, (node, pos) => {
-        if (applicable) return !1;
-        if (!(!node.isTextblock || node.hasMarkup(nodeType, attrs)))
-          if (node.type == nodeType)
-            applicable = !0;
-          else {
-            let $pos = state.doc.resolve(pos), index = $pos.index();
-            applicable = $pos.parent.canReplaceWith(index, index + 1, nodeType);
-          }
+        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 !1;
+    if (!applicable) return false;
     if (dispatch) {
-      let tr = state.tr;
-      for (let range of selection.ranges) {
-        let {
+      const tr = state.tr;
+      for (const range of selection.ranges) {
+        const {
           $from: { pos: from },
           $to: { pos: to }
         } = range;
@@ -187,34 +236,48 @@ function setBlockType(options) {
       }
       dispatch(tr.scrollIntoView());
     }
-    return !0;
+    return true;
   };
 }
 
 // src/utils/get-node-types.ts
 import "@prosekit/pm/model";
 function getNodeTypes(schema, types) {
-  return Array.isArray(types) ? types.map((type) => getNodeType(schema, type)) : [getNodeType(schema, types)];
+  if (Array.isArray(types)) {
+    return types.map((type) => getNodeType(schema, type));
+  }
+  return [getNodeType(schema, types)];
 }
 
 // src/commands/set-node-attrs.ts
 function setNodeAttrs(options) {
   return (state, dispatch) => {
     var _a, _b;
-    let nodeTypes = getNodeTypes(state.schema, options.type), from = (_a = options.pos) != null ? _a : state.selection.from, to = (_b = options.pos) != null ? _b : state.selection.to, positions = [];
-    if (state.doc.nodesBetween(from, to, (node, pos) => {
-      if (nodeTypes.includes(node.type) && positions.push(pos), !dispatch && positions.length > 0)
-        return !1;
-    }), positions.length === 0)
-      return !1;
+    const nodeTypes = getNodeTypes(state.schema, options.type);
+    const from = (_a = options.pos) != null ? _a : state.selection.from;
+    const to = (_b = options.pos) != null ? _b : state.selection.to;
+    const positions = [];
+    state.doc.nodesBetween(from, to, (node, pos) => {
+      if (nodeTypes.includes(node.type)) {
+        positions.push(pos);
+      }
+      if (!dispatch && positions.length > 0) {
+        return false;
+      }
+    });
+    if (positions.length === 0) {
+      return false;
+    }
     if (dispatch) {
-      let { tr } = state;
-      for (let pos of positions)
-        for (let [key, value] of Object.entries(options.attrs))
+      const { tr } = state;
+      for (const pos of positions) {
+        for (const [key, value] of Object.entries(options.attrs)) {
           tr.setNodeAttribute(pos, key, value);
+        }
+      }
       dispatch(tr);
     }
-    return !0;
+    return true;
   };
 }
 
@@ -222,69 +285,91 @@ function setNodeAttrs(options) {
 import "@prosekit/pm/model";
 import "@prosekit/pm/state";
 function markApplies(doc, ranges, type) {
-  for (let { $from, $to } of ranges) {
-    let can = $from.depth == 0 ? doc.inlineContent && doc.type.allowsMarkType(type) : !1;
-    if (doc.nodesBetween($from.pos, $to.pos, (node) => {
-      if (can) return !1;
+  for (const { $from, $to } of ranges) {
+    let can = $from.depth == 0 ? doc.inlineContent && doc.type.allowsMarkType(type) : false;
+    doc.nodesBetween($from.pos, $to.pos, (node) => {
+      if (can) return false;
       can = node.inlineContent && node.type.allowsMarkType(type);
-    }), can) return !0;
+    });
+    if (can) return true;
   }
-  return !1;
+  return false;
 }
 function baseToggleMark(markType, attrs = null, options) {
-  let removeWhenPresent = (options && options.removeWhenPresent) !== !1;
+  const removeWhenPresent = (options && options.removeWhenPresent) !== false;
   return function(state, dispatch) {
-    let { empty, $cursor, ranges } = state.selection;
+    const { empty, $cursor, ranges } = state.selection;
     if (empty && !$cursor || !markApplies(state.doc, ranges, markType))
-      return !1;
-    if (dispatch)
-      if ($cursor)
-        markType.isInSet(state.storedMarks || $cursor.marks()) ? dispatch(state.tr.removeStoredMark(markType)) : dispatch(state.tr.addStoredMark(markType.create(attrs)));
-      else {
-        let add, tr = state.tr;
-        removeWhenPresent ? add = !ranges.some(
-          (r) => state.doc.rangeHasMark(r.$from.pos, r.$to.pos, markType)
-        ) : add = !ranges.every((r) => {
-          let missing = !1;
-          return tr.doc.nodesBetween(r.$from.pos, r.$to.pos, (node, pos, parent) => {
-            if (missing) return !1;
-            missing = !markType.isInSet(node.marks) && !!parent && parent.type.allowsMarkType(markType) && !(node.isText && /^\s*$/.test(
-              node.textBetween(
-                Math.max(0, r.$from.pos - pos),
-                Math.min(node.nodeSize, r.$to.pos - pos)
-              )
-            ));
-          }), !missing;
-        });
-        for (let { $from, $to } of ranges)
-          if (!add)
+      return false;
+    if (dispatch) {
+      if ($cursor) {
+        if (markType.isInSet(state.storedMarks || $cursor.marks()))
+          dispatch(state.tr.removeStoredMark(markType));
+        else dispatch(state.tr.addStoredMark(markType.create(attrs)));
+      } else {
+        let add;
+        const tr = state.tr;
+        if (removeWhenPresent) {
+          add = !ranges.some(
+            (r) => state.doc.rangeHasMark(r.$from.pos, r.$to.pos, markType)
+          );
+        } else {
+          add = !ranges.every((r) => {
+            let missing = false;
+            tr.doc.nodesBetween(r.$from.pos, r.$to.pos, (node, pos, parent) => {
+              if (missing) return false;
+              missing = !markType.isInSet(node.marks) && !!parent && parent.type.allowsMarkType(markType) && !(node.isText && /^\s*$/.test(
+                node.textBetween(
+                  Math.max(0, r.$from.pos - pos),
+                  Math.min(node.nodeSize, r.$to.pos - pos)
+                )
+              ));
+            });
+            return !missing;
+          });
+        }
+        for (const { $from, $to } of ranges) {
+          if (!add) {
             tr.removeMark($from.pos, $to.pos, markType);
-          else {
-            let from = $from.pos, to = $to.pos, start = $from.nodeAfter, end = $to.nodeBefore, spaceStart = start && start.isText ? /^\s*/.exec(start.text)[0].length : 0, spaceEnd = end && end.isText ? /\s*$/.exec(end.text)[0].length : 0;
-            from + spaceStart < to && (from += spaceStart, to -= spaceEnd), tr.addMark(from, to, markType.create(attrs));
+          } else {
+            let from = $from.pos, to = $to.pos;
+            const start = $from.nodeAfter, end = $to.nodeBefore;
+            const spaceStart = start && start.isText ? /^\s*/.exec(start.text)[0].length : 0;
+            const spaceEnd = end && end.isText ? /\s*$/.exec(end.text)[0].length : 0;
+            if (from + spaceStart < to) {
+              from += spaceStart;
+              to -= spaceEnd;
+            }
+            tr.addMark(from, to, markType.create(attrs));
           }
+        }
         dispatch(tr.scrollIntoView());
       }
-    return !0;
+    }
+    return true;
   };
 }
 function toggleMark({ type, attrs }) {
-  return (state, dispatch, view) => baseToggleMark(getMarkType(state.schema, type), attrs, {
-    removeWhenPresent: !1
-  })(state, dispatch, view);
+  return (state, dispatch, view) => {
+    return baseToggleMark(getMarkType(state.schema, type), attrs, {
+      removeWhenPresent: false
+    })(state, dispatch, view);
+  };
 }
 
 // src/commands/toggle-node.ts
 import { setBlockType as setBlockType2 } from "@prosekit/pm/commands";
 import "@prosekit/pm/model";
-import "@prosekit/pm/state";
 function toggleNode({ type, attrs }) {
   return (state, dispatch, view) => {
     if (isNodeActive(state, type, attrs)) {
-      let defaultType = state.schema.topNodeType.contentMatch.defaultType;
-      return defaultType ? setBlockType2(defaultType)(state, dispatch, view) : !1;
+      const defaultType = state.schema.topNodeType.contentMatch.defaultType;
+      if (!defaultType) {
+        return false;
+      }
+      return setBlockType2(defaultType)(state, dispatch, view);
     } else {
-      let nodeType = getNodeType(state.schema, type);
+      const nodeType = getNodeType(state.schema, type);
       return setBlockType2(nodeType, attrs)(state, dispatch, view);
     }
   };
@@ -297,60 +382,74 @@ import { ReplaceAroundStep } from "@prosekit/pm/transform";
 function unsetBlockType(options) {
   return (state, dispatch) => {
     var _a, _b;
-    let from = (_a = options == null ? void 0 : options.from) != null ? _a : state.selection.from, to = (_b = options == null ? void 0 : options.to) != null ? _b : state.selection.to;
-    if (from > to) return !1;
-    let tr = state.tr;
-    return unsetTextBlockType(tr, from, to) ? (dispatch == null || dispatch(tr), !0) : !1;
+    const from = (_a = options == null ? void 0 : options.from) != null ? _a : state.selection.from;
+    const to = (_b = options == null ? void 0 : options.to) != null ? _b : state.selection.to;
+    if (from > to) return false;
+    const tr = state.tr;
+    if (unsetTextBlockType(tr, from, to)) {
+      dispatch == null ? void 0 : dispatch(tr);
+      return true;
+    }
+    return false;
   };
 }
 function unsetTextBlockType(tr, from, to) {
-  let mapFrom = tr.steps.length;
-  return tr.doc.nodesBetween(from, to, (node, pos, parent, index) => {
-    if (!parent || !node.isTextblock) return !0;
-    let defaultType = parent.contentMatchAt(index).defaultType;
+  const mapFrom = tr.steps.length;
+  tr.doc.nodesBetween(from, to, (node, pos, parent, index) => {
+    if (!parent || !node.isTextblock) return true;
+    const defaultType = parent.contentMatchAt(index).defaultType;
     if (defaultType && defaultType.isTextblock && node.type !== defaultType && defaultType.validContent(node.content)) {
-      let mapping = tr.mapping.slice(mapFrom), start = mapping.map(pos, 1), end = mapping.map(pos + node.nodeSize, 1), step = new ReplaceAroundStep(
+      const mapping = tr.mapping.slice(mapFrom);
+      const start = mapping.map(pos, 1);
+      const end = mapping.map(pos + node.nodeSize, 1);
+      const step = new ReplaceAroundStep(
         start,
         end,
         start + 1,
         end - 1,
         new Slice(Fragment.from(defaultType.create()), 0, 0),
         1,
-        !0
+        true
       );
       tr.step(step);
     }
-    return !1;
-  }), tr.steps.length > mapFrom;
+    return false;
+  });
+  return tr.steps.length > mapFrom;
 }
 
 // src/commands/unset-mark.ts
-import "@prosekit/pm/state";
 function unsetMark(options) {
   return (state, dispatch) => {
     var _a, _b;
-    let from = (_a = options == null ? void 0 : options.from) != null ? _a : state.selection.from, to = (_b = options == null ? void 0 : options.to) != null ? _b : state.selection.to;
-    return from > to ? !1 : (dispatch == null || dispatch(state.tr.removeMark(from, to)), !0);
+    const from = (_a = options == null ? void 0 : options.from) != null ? _a : state.selection.from;
+    const to = (_b = options == null ? void 0 : options.to) != null ? _b : state.selection.to;
+    if (from > to) return false;
+    dispatch == null ? void 0 : dispatch(state.tr.removeMark(from, to));
+    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) => {
-    let { $from, $to } = state.selection, range = $from.blockRange($to);
-    if (!range) return !1;
-    let wrapping = findWrapping(range, nodeType, attrs);
-    return wrapping ? (dispatch == null || dispatch(state.tr.wrap(range, wrapping)), !0) : !1;
+    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/editor/with-priority.ts
 function withPriority(extension, priority) {
-  let result = union(extension);
-  return result.priority = priority, result;
+  const result = union(extension);
+  result.priority = priority;
+  return result;
 }
 
 // src/commands/insert-text.ts
@@ -359,25 +458,36 @@ function insertText({
   from,
   to
 }) {
-  return (state, dispatch) => (text && (dispatch == null || dispatch(state.tr.insertText(text, from, to))), !0);
+  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 } from "@prosekit/pm/state";
 function selectAll() {
-  return (state, dispatch) => (dispatch == null || dispatch(state.tr.setSelection(new AllSelection(state.doc))), !0);
+  return (state, dispatch) => {
+    dispatch == null ? void 0 : dispatch(state.tr.setSelection(new AllSelection(state.doc)));
+    return true;
+  };
 }
 
 // src/facets/command.ts
 var commandFacet = defineFacet({
-  reducer: (inputs) => ({ commands: Object.assign({}, ...inputs) }),
+  reducer: (inputs) => {
+    const commands2 = Object.assign({}, ...inputs);
+    return { commands: commands2 };
+  },
   parent: rootFacet,
-  singleton: !0
+  singleton: true
 });
 
 // src/extensions/command.ts
-function defineCommands(commands) {
-  return defineFacetPayload(commandFacet, [commands]);
+function defineCommands(commands2) {
+  return defineFacetPayload(commandFacet, [commands2]);
 }
 function defineBaseCommands() {
   return defineCommands({
@@ -404,34 +514,49 @@ import OrderedMap from "orderedmap";
 var schemaSpecFacet = defineFacet({
   reducer: (specs) => {
     var _a;
-    let nodes = OrderedMap.from({}), marks = OrderedMap.from({}), topNode;
-    for (let spec of specs)
-      nodes = nodes.append(spec.nodes), marks = marks.append((_a = spec.marks) != null ? _a : {}), topNode = topNode != null ? topNode : spec.topNode;
+    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 };
   },
   parent: schemaFacet,
-  singleton: !0
+  singleton: true
 });
 
 // src/utils/is-element.ts
-var hasElement = typeof Element != "undefined";
+var hasElement = typeof Element !== "undefined";
 function isElement(value) {
   return hasElement && value instanceof Element;
 }
 
 // src/extensions/node-spec.ts
 function defineNodeSpec(options) {
-  return defineFacetPayload(nodeSpecFacet, [[options, void 0]]);
+  const payload = [options, void 0];
+  return defineFacetPayload(nodeSpecFacet, [payload]);
 }
 function defineNodeAttr(options) {
-  return defineFacetPayload(nodeSpecFacet, [[void 0, options]]);
+  const payload = [void 0, options];
+  return defineFacetPayload(nodeSpecFacet, [payload]);
 }
 var nodeSpecFacet = defineFacet({
   reducer: (payloads) => {
-    let nodes = OrderedMap2.from({}), topNodeName, specPayloads = payloads.map((input) => input[0]).filter(isNotNull), attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
-    for (let { name, topNode, ...spec } of specPayloads)
-      assert(!nodes.get(name), `Node type ${name} can only be defined once`), topNode && (topNodeName = name), nodes = nodes.addToStart(name, spec);
-    for (let {
+    let nodes = OrderedMap2.from({});
+    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) {
+      assert(!nodes.get(name), `Node type ${name} can only be defined once`);
+      if (topNode) {
+        topNodeName = name;
+      }
+      nodes = nodes.addToStart(name, spec);
+    }
+    for (const {
       type,
       attr,
       default: defaultValue,
@@ -439,57 +564,87 @@ var nodeSpecFacet = defineFacet({
       toDOM,
       parseDOM
     } of attrPayloads) {
-      let spec = nodes.get(type);
-      if (assert(spec, `Node type ${type} must be defined`), spec.attrs || (spec.attrs = {}), spec.attrs[attr] = {
+      const spec = nodes.get(type);
+      assert(spec, `Node type ${type} must be defined`);
+      if (!spec.attrs) {
+        spec.attrs = {};
+      }
+      spec.attrs[attr] = {
         default: defaultValue,
         splittable
-      }, toDOM && spec.toDOM) {
-        let existingToDom = spec.toDOM;
+      };
+      if (toDOM && spec.toDOM) {
+        const existingToDom = spec.toDOM;
         spec.toDOM = (node) => {
-          let dom = existingToDom(node);
-          if (!dom)
+          const dom = existingToDom(node);
+          if (!dom) {
             return dom;
-          let attrDOM = toDOM(node.attrs[attr]);
-          if (!attrDOM)
+          }
+          const attrDOM = toDOM(node.attrs[attr]);
+          if (!attrDOM) {
+            return dom;
+          }
+          const [key, value] = attrDOM;
+          if (!key) {
             return dom;
-          let [key, value] = attrDOM;
-          return key ? Array.isArray(dom) ? typeof dom[1] == "object" ? [
-            dom[0],
-            setObjectAttribute(
-              dom[1],
-              key,
-              value
-            ),
-            ...dom.slice(2)
-          ] : [dom[0], { [key]: value }, ...dom.slice(1)] : (isElement(dom) ? setElementAttribute(dom, key, value) : typeof dom == "object" && "dom" in dom && isElement(dom.dom) && setElementAttribute(dom.dom, key, value), dom) : dom;
+          }
+          if (Array.isArray(dom)) {
+            if (typeof dom[1] === "object") {
+              return [
+                dom[0],
+                setObjectAttribute(
+                  dom[1],
+                  key,
+                  value
+                ),
+                ...dom.slice(2)
+              ];
+            } else {
+              return [dom[0], { [key]: value }, ...dom.slice(1)];
+            }
+          } else if (isElement(dom)) {
+            setElementAttribute(dom, key, value);
+          } else if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
+            setElementAttribute(dom.dom, key, value);
+          }
+          return dom;
         };
       }
-      if (parseDOM && spec.parseDOM)
-        for (let rule of spec.parseDOM) {
-          let existingGetAttrs = rule.getAttrs, existingAttrs = rule.attrs;
+      if (parseDOM && spec.parseDOM) {
+        for (const rule of spec.parseDOM) {
+          const existingGetAttrs = rule.getAttrs;
+          const existingAttrs = rule.attrs;
           rule.getAttrs = (dom) => {
             var _a;
-            let attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
-            if (attrs === !1 || !dom || !isElement(dom))
+            const attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
+            if (attrs === false || !dom || !isElement(dom)) {
               return attrs != null ? attrs : null;
-            let value = parseDOM(dom);
+            }
+            const value = parseDOM(dom);
             return {
               ...attrs,
               [attr]: value
             };
           };
         }
+      }
     }
     return { nodes, topNode: topNodeName };
   },
   parent: schemaSpecFacet,
-  singleton: !0
+  singleton: true
 });
 function setObjectAttribute(obj, key, value) {
-  return key === "style" && (value = `${value}${obj.style || ""}`), { ...obj, [key]: value };
+  if (key === "style") {
+    value = `${value}${obj.style || ""}`;
+  }
+  return { ...obj, [key]: value };
 }
 function setElementAttribute(element, key, value) {
-  key === "style" && (value = `${value}${element.getAttribute("style") || ""}`), element.setAttribute(key, value);
+  if (key === "style") {
+    value = `${value}${element.getAttribute("style") || ""}`;
+  }
+  element.setAttribute(key, value);
 }
 
 // src/extensions/doc.ts
@@ -497,7 +652,7 @@ function defineDoc() {
   return defineNodeSpec({
     name: "doc",
     content: "block+",
-    topNode: !0
+    topNode: true
   });
 }
 
@@ -508,27 +663,35 @@ import { PluginKey, ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm
 import "@prosekit/pm/model";
 import { Plugin } from "@prosekit/pm/state";
 function definePlugin(plugin) {
-  if (plugin instanceof Plugin)
+  if (plugin instanceof Plugin) {
     return defineFacetPayload(pluginFacet, [() => [plugin]]);
-  if (Array.isArray(plugin) && plugin.every((p) => p instanceof Plugin))
+  }
+  if (Array.isArray(plugin) && plugin.every((p) => p instanceof Plugin)) {
     return defineFacetPayload(pluginFacet, [() => plugin]);
-  if (typeof plugin == "function")
+  }
+  if (typeof plugin === "function") {
     return defineFacetPayload(pluginFacet, [plugin]);
+  }
   throw new TypeError("Invalid plugin");
 }
 var pluginFacet = defineFacet({
-  reducer: (payloads) => ({ schema }) => {
-    let plugins = [];
-    for (let payload of payloads)
-      if (payload instanceof Plugin)
-        plugins.push(payload);
-      else if (Array.isArray(payload) && payload.every((p) => p instanceof Plugin))
-        plugins.push(...payload);
-      else if (typeof payload == "function")
-        plugins.push(...[payload({ schema })].flat());
-      else
-        throw new ProseKitError("Invalid plugin");
-    return plugins.reverse(), { plugins };
+  reducer: (payloads) => {
+    return ({ schema }) => {
+      const plugins = [];
+      for (const payload of payloads) {
+        if (payload instanceof Plugin) {
+          plugins.push(payload);
+        } else if (Array.isArray(payload) && payload.every((p) => p instanceof Plugin)) {
+          plugins.push(...payload);
+        } else if (typeof payload === "function") {
+          plugins.push(...[payload({ schema })].flat());
+        } else {
+          throw new ProseKitError("Invalid plugin");
+        }
+      }
+      plugins.reverse();
+      return { plugins };
+    };
   },
   parent: stateFacet
 });
@@ -545,19 +708,28 @@ function defineUnmountHandler(handler) {
 }
 var pluginViewFacet = defineFacet({
   reduce: () => {
-    let mountHandlers = [], updateHandlers = [], unmountHandlers = [], plugin = new ProseMirrorPlugin2({
+    let mountHandlers = [];
+    let updateHandlers = [];
+    let unmountHandlers = [];
+    const plugin = new ProseMirrorPlugin2({
       key: pluginKey,
-      view: (view) => (mountHandlers.forEach((fn) => fn(view)), {
-        update: (view2, prevState) => {
-          updateHandlers.forEach((fn) => fn(view2, prevState));
-        },
-        destroy: () => {
-          unmountHandlers.forEach((fn) => fn());
-        }
-      })
-    }), register = (input) => {
-      mountHandlers = [], updateHandlers = [], unmountHandlers = [];
-      for (let args of input)
+      view: (view) => {
+        mountHandlers.forEach((fn) => fn(view));
+        return {
+          update: (view2, prevState) => {
+            updateHandlers.forEach((fn) => fn(view2, prevState));
+          },
+          destroy: () => {
+            unmountHandlers.forEach((fn) => fn());
+          }
+        };
+      }
+    });
+    const register = (input) => {
+      mountHandlers = [];
+      updateHandlers = [];
+      unmountHandlers = [];
+      for (const args of input) {
         switch (args[0]) {
           case "mount":
             mountHandlers.push(args[1]);
@@ -569,19 +741,24 @@ var pluginViewFacet = defineFacet({
             unmountHandlers.push(args[1]);
             break;
         }
+      }
     };
-    return function(input) {
-      return register(input), plugin;
+    return function reducer(input) {
+      register(input);
+      return plugin;
     };
   },
   parent: pluginFacet,
-  singleton: !0
-}), pluginKey = new PluginKey("prosekit-plugin-view-handler");
+  singleton: true
+});
+var pluginKey = new PluginKey("prosekit-plugin-view-handler");
 
 // src/extensions/events/doc-change.ts
 function defineDocChangeHandler(handler) {
   return defineUpdateHandler((view, prevState) => {
-    view.state.doc.eq(prevState.doc) || handler(view, prevState);
+    if (!view.state.doc.eq(prevState.doc)) {
+      handler(view, prevState);
+    }
   });
 }
 
@@ -595,20 +772,26 @@ function combineEventHandlers() {
     _handlers = toReversed(handlers);
   }
   function combinedEventHandler(...args) {
-    for (let handler of _handlers)
-      if (handler(...args))
-        return !0;
-    return !1;
+    for (const handler of _handlers) {
+      if (handler(...args)) {
+        return true;
+      }
+    }
+    return false;
   }
   return [setHandlers, combinedEventHandler];
 }
 
 // src/utils/group-entries.ts
 function groupEntries(entries) {
-  let map = {};
-  for (let [key, value] of entries) {
-    let values = map[key];
-    values ? values.push(value) : map[key] = [value];
+  const map = {};
+  for (const [key, value] of entries) {
+    const values = map[key];
+    if (!values) {
+      map[key] = [value];
+    } else {
+      values.push(value);
+    }
   }
   return map;
 }
@@ -621,33 +804,42 @@ function defineDOMEventHandler(event, handler) {
 }
 var domEventFacet = defineFacet({
   reduce: () => {
-    let setHandlersMap = {}, combinedHandlerMap = {}, plugin, update = (payloads) => {
+    const setHandlersMap = {};
+    const combinedHandlerMap = {};
+    let plugin;
+    const update = (payloads) => {
       var _a;
-      let hasNewEvent = !1;
-      for (let [event] of payloads)
+      let hasNewEvent = false;
+      for (const [event] of payloads) {
         if (!setHandlersMap[event]) {
-          hasNewEvent = !0;
-          let [setHandlers, combinedHandler] = combineEventHandlers();
+          hasNewEvent = true;
+          const [setHandlers, combinedHandler] = combineEventHandlers();
           setHandlersMap[event] = setHandlers;
-          let e = (view, eventObject) => combinedHandler(view, eventObject);
+          const e = (view, eventObject) => {
+            return combinedHandler(view, eventObject);
+          };
           combinedHandlerMap[event] = e;
         }
-      let map = groupEntries(payloads);
-      for (let [event, setHandlers] of Object.entries(setHandlersMap)) {
-        let handlers = (_a = map[event]) != null ? _a : [];
+      }
+      const map = groupEntries(payloads);
+      for (const [event, setHandlers] of Object.entries(setHandlersMap)) {
+        const handlers = (_a = map[event]) != null ? _a : [];
         setHandlers(handlers);
       }
-      hasNewEvent && (plugin = new ProseMirrorPlugin3({
-        key: new PluginKey2("prosekit-dom-event-handler"),
-        props: { handleDOMEvents: combinedHandlerMap }
-      }));
+      if (hasNewEvent) {
+        plugin = new ProseMirrorPlugin3({
+          key: new PluginKey2("prosekit-dom-event-handler"),
+          props: { handleDOMEvents: combinedHandlerMap }
+        });
+      }
     };
-    return function(inputs) {
-      return update(inputs), plugin != null ? plugin : [];
+    return function reducer(inputs) {
+      update(inputs);
+      return plugin != null ? plugin : [];
     };
   },
   parent: pluginFacet,
-  singleton: !0
+  singleton: true
 });
 
 // src/extensions/events/editor-event.ts
@@ -690,18 +882,45 @@ function defineScrollToSelectionHandler(handler) {
 }
 var editorEventFacet = defineFacet({
   reduce: () => {
-    let [update, plugin] = setupEditorEventPlugin();
-    return (entries) => (update(entries), plugin);
+    const [update, plugin] = setupEditorEventPlugin();
+    return (entries) => {
+      update(entries);
+      return plugin;
+    };
   },
   parent: pluginFacet,
-  singleton: !0
+  singleton: true
 });
 function setupEditorEventPlugin() {
-  let [setKeyDownHandlers, handleKeyDown] = combineEventHandlers(), [setKeyPressHandlers, handleKeyPress] = combineEventHandlers(), [setTextInputHandlers, handleTextInput] = combineEventHandlers(), [setClickOnHandlers, handleClickOn] = combineEventHandlers(), [setClickHandlers, handleClick] = combineEventHandlers(), [setDoubleClickOnHandlers, handleDoubleClickOn] = combineEventHandlers(), [setDoubleClickHandlers, handleDoubleClick] = combineEventHandlers(), [setTripleClickOnHandlers, handleTripleClickOn] = combineEventHandlers(), [setTripleClickHandlers, handleTripleClick] = combineEventHandlers(), [setPasteHandlers, handlePaste] = combineEventHandlers(), [setDropHandlers, handleDrop] = combineEventHandlers(), [setScrollToSelectionHandlers, handleScrollToSelection] = combineEventHandlers(), update = (entries) => {
+  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;
-    let 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 : []);
-  }, plugin = new ProseMirrorPlugin4({
+    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 ProseMirrorPlugin4({
     key: new PluginKey3("prosekit-editor-event"),
     props: {
       handleKeyDown,
@@ -723,9 +942,11 @@ function setupEditorEventPlugin() {
 
 // src/extensions/events/focus.ts
 function defineFocusChangeHandler(handler) {
+  const handleFocus = () => handler(true);
+  const handleBlur = () => handler(false);
   return defineFacetPayload(domEventFacet, [
-    ["focus", () => handler(!0)],
-    ["blur", () => handler(!1)]
+    ["focus", handleFocus],
+    ["blur", handleBlur]
   ]);
 }
 
@@ -733,58 +954,76 @@ function defineFocusChangeHandler(handler) {
 import { history, redo, undo } from "@prosekit/pm/history";
 
 // src/utils/env.ts
-var isApple = typeof navigator != "undefined" ? /Mac|iP(hone|[ao]d)/.test(navigator.platform) : !1;
+var isApple = typeof navigator !== "undefined" ? /Mac|iP(hone|[ao]d)/.test(navigator.platform) : false;
 
 // src/extensions/keymap.ts
 import { chainCommands } from "@prosekit/pm/commands";
 import { keydownHandler } from "@prosekit/pm/keymap";
 import { Plugin as Plugin2, PluginKey as PluginKey4 } from "@prosekit/pm/state";
-function defineKeymap(keymap) {
-  return defineFacetPayload(keymapFacet, [keymap]);
+function defineKeymap(keymap2) {
+  return defineFacetPayload(keymapFacet, [keymap2]);
 }
 var keymapFacet = defineFacet({
   reduce: () => {
-    let handler, handlerWrapper = (view, event) => handler ? handler(view, event) : !1, plugin = new Plugin2({
+    let handler;
+    const handlerWrapper = (view, event) => {
+      if (handler) return handler(view, event);
+      return false;
+    };
+    const plugin = new Plugin2({
       key: keymapPluginKey,
       props: { handleKeyDown: handlerWrapper }
     });
-    return (keymaps) => (handler = keydownHandler(
-      mergeKeymaps(
-        // The keymap at the end have a higher priority.
-        toReversed(keymaps)
-      )
-    ), plugin);
+    return (keymaps) => {
+      handler = keydownHandler(
+        mergeKeymaps(
+          // The keymap at the end have a higher priority.
+          toReversed(keymaps)
+        )
+      );
+      return plugin;
+    };
   },
   parent: pluginFacet,
-  singleton: !0
+  singleton: true
 });
 function mergeKeymaps(keymaps) {
-  let bindings = {};
-  for (let keymap of keymaps)
-    for (let [key, command] of Object.entries(keymap))
-      (bindings[key] || (bindings[key] = [])).push(command);
+  const bindings = {};
+  for (const keymap2 of keymaps) {
+    for (const [key, command] of Object.entries(keymap2)) {
+      const commands2 = bindings[key] || (bindings[key] = []);
+      commands2.push(command);
+    }
+  }
   return Object.fromEntries(
-    Object.entries(bindings).map(([key, commands]) => [
+    Object.entries(bindings).map(([key, commands2]) => [
       key,
-      chainCommands(...commands)
+      chainCommands(...commands2)
     ])
   );
 }
 var keymapPluginKey = new PluginKey4("prosekit-keymap");
 
 // src/extensions/history.ts
-function defineHistory() {
-  let keymap = {
-    "Mod-z": undo,
-    "Shift-Mod-z": redo
-  };
-  return isApple || (keymap["Mod-y"] = redo), union([
-    definePlugin(history()),
+var keymap = {
+  "Mod-z": undo,
+  "Shift-Mod-z": redo
+};
+if (!isApple) {
+  keymap["Mod-y"] = redo;
+}
+var commands = {
+  undo: () => undo,
+  redo: () => redo
+};
+function defineHistory({
+  depth = 200,
+  newGroupDelay = 250
+} = {}) {
+  return union([
+    definePlugin(history({ depth, newGroupDelay })),
     defineKeymap(keymap),
-    defineCommands({
-      undo: () => undo,
-      redo: () => redo
-    })
+    defineCommands(commands)
   ]);
 }
 
@@ -805,94 +1044,127 @@ var customEnter = chainCommands2(
   createParagraphNear,
   liftEmptyBlock,
   splitSplittableBlock
-), customBackspace = chainCommands2(
+);
+var customBackspace = chainCommands2(
   deleteSelection,
   joinTextblockBackward,
   selectNodeBackward
-), customBaseKeymap = {
+);
+var customBaseKeymap = {
   ...baseKeymap,
   Enter: customEnter,
   Backspace: customBackspace
 };
 function defineBaseKeymap(options) {
   var _a;
-  let priority = (_a = options == null ? void 0 : options.priority) != null ? _a : 1 /* low */;
+  const priority = (_a = options == null ? void 0 : options.priority) != null ? _a : 1 /* low */;
   return withPriority(defineKeymap(customBaseKeymap), priority);
 }
 
 // src/extensions/mark-spec.ts
 function defineMarkSpec(options) {
-  return defineFacetPayload(markSpecFacet, [[options, void 0]]);
+  const payload = [options, void 0];
+  return defineFacetPayload(markSpecFacet, [payload]);
 }
 function defineMarkAttr(options) {
-  return defineFacetPayload(markSpecFacet, [[void 0, options]]);
+  const payload = [void 0, options];
+  return defineFacetPayload(markSpecFacet, [payload]);
 }
 var markSpecFacet = defineFacet({
   reducer: (payloads) => {
-    let marks = {}, specPayloads = payloads.map((input) => input[0]).filter(isNotNull), attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
-    for (let { name, ...spec } of specPayloads) {
-      if (marks[name])
+    const marks = {};
+    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 (let {
+    for (const {
       type,
       attr,
       default: defaultValue,
       toDOM,
       parseDOM
     } of attrPayloads) {
-      let spec = marks[type];
-      if (!spec)
+      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 }, toDOM && spec.toDOM) {
-        let existingToDom = spec.toDOM;
+      }
+      if (!spec.attrs) {
+        spec.attrs = {};
+      }
+      spec.attrs[attr] = { default: defaultValue };
+      if (toDOM && spec.toDOM) {
+        const existingToDom = spec.toDOM;
         spec.toDOM = (mark, inline) => {
-          let dom = existingToDom(mark, inline);
-          if (!dom)
+          const dom = existingToDom(mark, inline);
+          if (!dom) {
             return dom;
-          let attrDOM = toDOM(mark.attrs[attr]);
-          if (!attrDOM)
+          }
+          const attrDOM = toDOM(mark.attrs[attr]);
+          if (!attrDOM) {
             return dom;
-          let [key, value] = attrDOM;
-          return key ? Array.isArray(dom) ? typeof dom[1] == "object" ? [dom[0], { ...dom[1], [key]: value }, ...dom.slice(2)] : [dom[0], { [key]: value }, ...dom.slice(1)] : (isElement(dom) ? dom.setAttribute(key, value) : typeof dom == "object" && "dom" in dom && isElement(dom.dom) && dom.dom.setAttribute(key, value), dom) : 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 (let rule of spec.parseDOM) {
-          let existingGetAttrs = rule.getAttrs, existingAttrs = rule.attrs;
+      if (parseDOM && spec.parseDOM) {
+        for (const rule of spec.parseDOM) {
+          const existingGetAttrs = rule.getAttrs;
+          const existingAttrs = rule.attrs;
           rule.getAttrs = (dom) => {
             var _a;
-            let attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
-            if (attrs === !1 || !dom || !isElement(dom))
+            const attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
+            if (attrs === false || !dom || !isElement(dom)) {
               return attrs != null ? attrs : null;
-            let value = parseDOM(dom);
+            }
+            const value = parseDOM(dom);
             return {
               ...attrs,
               [attr]: value
             };
           };
         }
+      }
     }
     return { marks, nodes: {} };
   },
   parent: schemaSpecFacet,
-  singleton: !0
+  singleton: true
 });
 
 // src/extensions/node-view.ts
 import { PluginKey as PluginKey5, ProseMirrorPlugin as ProseMirrorPlugin5 } from "@prosekit/pm/state";
-import "@prosekit/pm/view";
 function defineNodeView(options) {
   return defineFacetPayload(nodeViewFacet, [options]);
 }
 var nodeViewFacet = defineFacet({
   reducer: (inputs) => {
-    let nodeViews = {};
-    for (let input of inputs)
-      nodeViews[input.name] || (nodeViews[input.name] = input.constructor);
+    const nodeViews = {};
+    for (const input of inputs) {
+      if (!nodeViews[input.name]) {
+        nodeViews[input.name] = input.constructor;
+      }
+    }
     return () => [
       new ProseMirrorPlugin5({
         key: new PluginKey5("prosekit-node-view"),
@@ -905,19 +1177,25 @@ var nodeViewFacet = defineFacet({
 
 // src/extensions/node-view-effect.ts
 import { PluginKey as PluginKey6, ProseMirrorPlugin as ProseMirrorPlugin6 } from "@prosekit/pm/state";
-import "@prosekit/pm/view";
 function defineNodeViewFactory(options) {
-  return defineFacetPayload(nodeViewFactoryFacet, [[options, null]]);
+  const input = [options, null];
+  return defineFacetPayload(nodeViewFactoryFacet, [input]);
 }
 function defineNodeViewComponent(options) {
-  return defineFacetPayload(nodeViewFactoryFacet, [[null, options]]);
+  const input = [null, options];
+  return defineFacetPayload(nodeViewFactoryFacet, [input]);
 }
+var isServer = typeof window === "undefined";
 var nodeViewFactoryFacet = defineFacet({
   reducer: (inputs) => {
-    let nodeViews = {}, factories = inputs.map((x) => x[0]).filter(isNotNull), options = inputs.map((x) => x[1]).filter(isNotNull);
-    for (let { group, name, args } of options) {
-      let factory = factories.find((factory2) => factory2.group === group);
-      factory && (nodeViews[name] = factory.factory(args));
+    if (isServer) return [];
+    const nodeViews = {};
+    const factories = inputs.map((x) => x[0]).filter(isNotNull);
+    const options = inputs.map((x) => x[1]).filter(isNotNull);
+    for (const { group, name, args } of options) {
+      const factory = factories.find((factory2) => factory2.group === group);
+      if (!factory) continue;
+      nodeViews[name] = factory.factory(args);
     }
     return () => [
       new ProseMirrorPlugin6({
@@ -955,8 +1233,13 @@ function defineText() {
 
 // src/utils/cache.ts
 function cache(fn) {
-  let result;
-  return () => (result === void 0 && (result = fn()), result);
+  let result = void 0;
+  return () => {
+    if (result === void 0) {
+      result = fn();
+    }
+    return result;
+  };
 }
 
 // src/utils/can-use-regex-lookbehind.ts
@@ -964,7 +1247,7 @@ var canUseRegexLookbehind = cache(() => {
   try {
     return "ab".replace(new RegExp("(?<=a)b", "g"), "c") === "ac";
   } catch (error) {
-    return !1;
+    return false;
   }
 });
 
@@ -975,14 +1258,17 @@ var clsx = clsxLite;
 // src/utils/collect-nodes.ts
 import { ProseMirrorFragment, ProseMirrorNode as ProseMirrorNode2 } from "@prosekit/pm/model";
 function collectNodes(content) {
-  if (Array.isArray(content))
+  if (Array.isArray(content)) {
     return content.flatMap(collectNodes);
-  if (content instanceof ProseMirrorNode2)
+  }
+  if (content instanceof ProseMirrorNode2) {
     return [content];
+  }
   if (content instanceof ProseMirrorFragment) {
-    let nodes = [];
-    for (let i = 0; i < content.childCount; i++)
+    const nodes = [];
+    for (let i = 0; i < content.childCount; i++) {
       nodes.push(content.child(i));
+    }
     return nodes;
   }
   throw new ProseKitError(`Invalid node content: ${typeof content}`);
@@ -991,7 +1277,7 @@ function collectNodes(content) {
 // src/utils/default-block-at.ts
 function defaultBlockAt(match) {
   for (let i = 0; i < match.edgeCount; i++) {
-    let { type } = match.edge(i);
+    const { type } = match.edge(i);
     if (type.isTextblock && !type.hasRequiredAttrs()) return type;
   }
   return null;
@@ -1000,13 +1286,16 @@ function defaultBlockAt(match) {
 // src/utils/get-id.ts
 var id = 0;
 function getId() {
-  return id = (id + 1) % Number.MAX_SAFE_INTEGER, `id:${id}`;
+  id = (id + 1) % Number.MAX_SAFE_INTEGER;
+  return `id:${id}`;
 }
 
 // src/utils/is-at-block-start.ts
 function isAtBlockStart(state, view) {
-  let { $cursor } = state.selection;
-  return !$cursor || (view ? !view.endOfTextblock("backward", state) : $cursor.parentOffset > 0) ? null : $cursor;
+  const { $cursor } = state.selection;
+  if (!$cursor || (view ? !view.endOfTextblock("backward", state) : $cursor.parentOffset > 0))
+    return null;
+  return $cursor;
 }
 
 // src/utils/is-in-code-block.ts
@@ -1019,7 +1308,7 @@ function isInCodeBlock(selection) {
 
 // src/utils/maybe-run.ts
 function maybeRun(value, ...args) {
-  return typeof value == "function" ? value(...args) : value;
+  return typeof value === "function" ? value(...args) : value;
 }
 
 // src/utils/unicode.ts
@@ -1027,7 +1316,12 @@ var OBJECT_REPLACEMENT_CHARACTER = "\uFFFC";
 
 // src/utils/with-skip-code-block.ts
 function withSkipCodeBlock(command) {
-  return (state, dispatch, view) => isInCodeBlock(state.selection) ? !1 : command(state, dispatch, view);
+  return (state, dispatch, view) => {
+    if (isInCodeBlock(state.selection)) {
+      return false;
+    }
+    return command(state, dispatch, view);
+  };
 }
 export {
   Editor,