@prosekit/core 0.0.0-next-20240724172520 → 0.0.0-next-20240901092634

package/dist/prosekit-core.js

@@ -15,13 +15,17 @@ import {
   htmlFromJSON,
   htmlFromNode,
   isAllSelection,
+  isElement,
+  isFragment,
   isMark,
   isMarkAbsent,
   isMarkActive,
   isNodeActive,
   isNodeSelection,
-  isNotNull,
+  isNotNullish,
   isProseMirrorNode,
+  isSelection,
+  isSlice,
   isTextSelection,
   jsonFromHTML,
   jsonFromNode,
@@ -35,10 +39,9 @@ import {
   stateFromJSON,
   toReversed,
   union
-} from "./chunk-MOSGJZHV.js";
+} from "./chunk-RNBMCB5M.js";
 
 // src/commands/add-mark.ts
-import "@prosekit/pm/model";
 function addMark(options) {
   return (state, dispatch) => {
     var _a, _b;
@@ -139,8 +142,42 @@ function insertNode(options) {
   };
 }
 
+// src/commands/insert-default-block.ts
+import { TextSelection as TextSelection3 } from "@prosekit/pm/state";
+
+// src/utils/default-block-at.ts
+function defaultBlockAt(match) {
+  for (let i = 0; i < match.edgeCount; i++) {
+    const { type } = match.edge(i);
+    if (type.isTextblock && !type.hasRequiredAttrs()) return type;
+  }
+  return null;
+}
+
+// src/commands/insert-default-block.ts
+function insertDefaultBlock(options) {
+  return (state, dispatch) => {
+    const $pos = (options == null ? void 0 : options.pos) == null ? state.selection.$to : state.doc.resolve(options.pos);
+    const depth = $pos.parent.isTextblock ? $pos.depth - 1 : $pos.depth;
+    const parent = $pos.node(depth);
+    const index = $pos.indexAfter(depth);
+    const type = defaultBlockAt(parent.contentMatchAt(index));
+    if (!type) return false;
+    if (dispatch) {
+      const pos = $pos.posAtIndex(index, depth);
+      const node = type.createAndFill();
+      if (!node) return false;
+      const tr = state.tr.insert(pos, node);
+      const selection = TextSelection3.findFrom(tr.doc.resolve(pos), 1);
+      if (!selection) return false;
+      tr.setSelection(selection);
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+}
+
 // src/commands/remove-mark.ts
-import "@prosekit/pm/model";
 function removeMark(options) {
   return (state, dispatch) => {
     var _a, _b;
@@ -157,46 +194,43 @@ function removeMark(options) {
 }
 
 // src/utils/find-parent-node.ts
-function findParentNode(nodeType, $pos) {
-  for (let depth = $pos.depth; depth > 0; depth -= 1) {
+function findParentNode(predicate, $pos) {
+  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
-      };
+    if (predicate(node)) {
+      const pos = depth === 0 ? 0 : $pos.before(depth);
+      const start = $pos.start(depth);
+      return { node, pos, start, depth };
     }
   }
-  return {
-    from: null,
-    to: null
-  };
+}
+
+// src/utils/find-parent-node-of-type.ts
+function findParentNodeOfType(type, $pos) {
+  const nodeType = getNodeType($pos.doc.type.schema, type);
+  return findParentNode((node) => node.type === nodeType, $pos);
 }
 
 // src/commands/remove-node.ts
 function removeNode(options) {
   return (state, dispatch) => {
-    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));
+    const found = findParentNodeOfType(options.type, $pos);
+    if (!found) return false;
+    const { pos, node } = found;
+    dispatch == null ? void 0 : dispatch(state.tr.delete(pos, pos + node.nodeSize));
     return true;
   };
 }
 
 // src/utils/get-custom-selection.ts
-import { TextSelection as TextSelection3 } from "@prosekit/pm/state";
+import { TextSelection as TextSelection4 } 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 TextSelection4.between($from, $to);
   }
   return state.selection;
 }
@@ -241,7 +275,6 @@ function setBlockType(options) {
 }
 
 // src/utils/get-node-types.ts
-import "@prosekit/pm/model";
 function getNodeTypes(schema, types) {
   if (Array.isArray(types)) {
     return types.map((type) => getNodeType(schema, type));
@@ -282,84 +315,23 @@ function setNodeAttrs(options) {
 }
 
 // src/commands/toggle-mark.ts
-import "@prosekit/pm/model";
-import "@prosekit/pm/state";
-function markApplies(doc, ranges, type) {
-  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);
-    });
-    if (can) return true;
-  }
-  return false;
-}
-function baseToggleMark(markType, attrs = null, options) {
-  const removeWhenPresent = (options && options.removeWhenPresent) !== false;
-  return function(state, dispatch) {
-    const { empty, $cursor, ranges } = state.selection;
-    if (empty && !$cursor || !markApplies(state.doc, ranges, markType))
-      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;
-            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 true;
-  };
-}
-function toggleMark({ type, attrs }) {
+import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
+function toggleMark({
+  type,
+  attrs,
+  removeWhenPresent = false,
+  enterInlineAtoms = true
+}) {
   return (state, dispatch, view) => {
     return baseToggleMark(getMarkType(state.schema, type), attrs, {
-      removeWhenPresent: false
+      removeWhenPresent,
+      enterInlineAtoms
     })(state, dispatch, view);
   };
 }
 
 // src/commands/toggle-node.ts
 import { setBlockType as setBlockType2 } from "@prosekit/pm/commands";
-import "@prosekit/pm/model";
 function toggleNode({ type, attrs }) {
   return (state, dispatch, view) => {
     if (isNodeActive(state, type, attrs)) {
@@ -377,7 +349,6 @@ function toggleNode({ type, attrs }) {
 
 // src/commands/unset-block-type.ts
 import { Fragment, Slice } from "@prosekit/pm/model";
-import "@prosekit/pm/state";
 import { ReplaceAroundStep } from "@prosekit/pm/transform";
 function unsetBlockType(options) {
   return (state, dispatch) => {
@@ -431,14 +402,14 @@ function unsetMark(options) {
 }
 
 // src/commands/wrap.ts
-import "@prosekit/pm/model";
 import { findWrapping } from "@prosekit/pm/transform";
-function wrap({ nodeType, attrs }) {
+function wrap(options) {
   return (state, dispatch) => {
     const { $from, $to } = state.selection;
     const range = $from.blockRange($to);
     if (!range) return false;
-    const wrapping = findWrapping(range, nodeType, attrs);
+    const nodeType = getNodeType(state.schema, options.nodeType || options.type);
+    const wrapping = findWrapping(range, nodeType, options.attrs);
     if (!wrapping) return false;
     dispatch == null ? void 0 : dispatch(state.tr.wrap(range, wrapping));
     return true;
@@ -493,6 +464,7 @@ function defineBaseCommands() {
     wrap,
     setBlockType,
     setNodeAttrs,
+    insertDefaultBlock,
     selectAll,
     addMark,
     removeMark,
@@ -502,10 +474,10 @@ function defineBaseCommands() {
 }
 
 // src/extensions/node-spec.ts
+import clone from "just-clone";
 import OrderedMap2 from "orderedmap";
 
 // src/facets/schema-spec.ts
-import "@prosekit/pm/model";
 import OrderedMap from "orderedmap";
 var schemaSpecFacet = defineFacet({
   reducer: (specs) => {
@@ -524,10 +496,137 @@ var schemaSpecFacet = defineFacet({
   singleton: true
 });
 
-// src/utils/is-element.ts
-var hasElement = typeof Element !== "undefined";
-function isElement(value) {
-  return hasElement && value instanceof Element;
+// src/utils/array-grouping.ts
+function groupBy(items, keySelector) {
+  const result = {};
+  for (const item of items) {
+    const key = keySelector(item);
+    const values = result[key] || (result[key] = []);
+    values.push(item);
+  }
+  return result;
+}
+function groupEntries(entries) {
+  const result = {};
+  for (const [key, value] of entries) {
+    const values = result[key] || (result[key] = []);
+    values.push(value);
+  }
+  return result;
+}
+
+// src/utils/remove-undefined-values.ts
+function removeUndefinedValues(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/utils/merge-objects.ts
+function mergeObjects(...objects) {
+  const filteredObjects = objects.filter(isNotNullish).map(removeUndefinedValues);
+  return Object.assign({}, ...filteredObjects);
+}
+
+// src/utils/merge-specs.ts
+function mergeSpecs(a, b) {
+  var _a, _b, _c, _d, _e, _f;
+  const attrs = {};
+  const attrNames = /* @__PURE__ */ new Set([
+    ...Object.keys((_a = a.attrs) != null ? _a : {}),
+    ...Object.keys((_b = b.attrs) != null ? _b : {})
+  ]);
+  for (const name of attrNames) {
+    const attrSpecA = (_c = a.attrs) == null ? void 0 : _c[name];
+    const attrSpecB = (_d = b.attrs) == null ? void 0 : _d[name];
+    const attrSpecMerged = mergeObjects(attrSpecA, attrSpecB);
+    if (attrSpecMerged) {
+      attrs[name] = attrSpecMerged;
+    }
+  }
+  const parseDOM = [...(_e = a.parseDOM) != null ? _e : [], ...(_f = b.parseDOM) != null ? _f : []];
+  return mergeObjects(a, b, { attrs, parseDOM });
+}
+
+// src/utils/output-spec.ts
+function wrapOutputSpecAttrs(toDOM, options) {
+  return (node, ...args) => {
+    const dom = toDOM(node, ...args);
+    const pairs = options.map((option) => {
+      var _a;
+      return (_a = option.toDOM) == null ? void 0 : _a.call(option, node.attrs[option.attr]);
+    }).filter(isNotNullish);
+    return insertOutputSpecAttrs(dom, pairs);
+  };
+}
+function wrapTagParseRuleAttrs(rule, options) {
+  const existingGetAttrs = rule.getAttrs;
+  const existingAttrs = rule.attrs;
+  return {
+    ...rule,
+    getAttrs: (dom) => {
+      var _a, _b;
+      const baseAttrs = (_b = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs) != null ? _b : {};
+      if (baseAttrs === false || !dom || !isElement(dom)) {
+        return baseAttrs != null ? baseAttrs : null;
+      }
+      const insertedAttrs = {};
+      for (const option of options) {
+        if (option.parseDOM) {
+          insertedAttrs[option.attr] = option.parseDOM(dom);
+        }
+      }
+      return { ...baseAttrs, ...insertedAttrs };
+    }
+  };
+}
+function insertOutputSpecAttrs(dom, attrs) {
+  if (!dom) {
+    return dom;
+  }
+  if (Array.isArray(dom)) {
+    const rest = dom.slice(1);
+    let oldAttrs;
+    if (rest.length > 0 && (rest[0] == null || typeof rest[0] === "object")) {
+      oldAttrs = rest.shift();
+    } else {
+      oldAttrs = {};
+    }
+    const newAttrs = setObjectAttributes(oldAttrs, attrs);
+    return [dom[0], newAttrs, ...rest];
+  }
+  if (isElement(dom)) {
+    return setElementAttributes(dom, attrs);
+  }
+  if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
+    return { ...dom, dom: setElementAttributes(dom.dom, attrs) };
+  }
+  return dom;
+}
+function setObjectAttributes(obj, attrs) {
+  obj = { ...obj };
+  for (const [key, value] of attrs) {
+    const oldValue = obj[key];
+    const newValue = key === "style" ? joinStyles(value, typeof oldValue === "string" ? oldValue : "") : value;
+    obj[key] = newValue;
+  }
+  return obj;
+}
+function setElementAttributes(element, attrs) {
+  element = element.cloneNode(true);
+  for (const [key, value] of attrs) {
+    const oldValue = element.getAttribute(key);
+    const newValue = key === "style" ? joinStyles(value, typeof oldValue === "string" ? oldValue : "") : value;
+    element.setAttribute(key, newValue);
+  }
+  return element;
+}
+function joinStyles(...styles) {
+  return styles.map((style) => style.trim().replace(/;$/, "")).filter(Boolean).join("; ");
 }
 
 // src/extensions/node-spec.ts
@@ -543,105 +642,50 @@ var nodeSpecFacet = defineFacet({
   reducer: (payloads) => {
     let specs = OrderedMap2.from({});
     let topNodeName = void 0;
-    const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
-    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
+    const specPayloads = payloads.map((input) => input[0]).filter(isNotNullish);
+    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNullish);
     for (const { name, topNode, ...spec } of specPayloads) {
-      assert(!specs.get(name), `Node type ${name} can only be defined once`);
       if (topNode) {
         topNodeName = name;
       }
-      specs = specs.addToStart(name, spec);
+      const prevSpec = specs.get(name);
+      if (prevSpec) {
+        specs = specs.update(name, mergeSpecs(prevSpec, spec));
+      } else {
+        specs = specs.addToStart(name, spec);
+      }
     }
-    for (const {
-      type,
-      attr,
-      default: defaultValue,
-      splittable,
-      toDOM,
-      parseDOM
-    } of attrPayloads) {
-      const spec = specs.get(type);
-      assert(spec, `Node type ${type} must be defined`);
+    const groupedAttrs = groupBy(attrPayloads, (payload) => payload.type);
+    for (const [type, attrs] of Object.entries(groupedAttrs)) {
+      if (!attrs) continue;
+      const maybeSpec = specs.get(type);
+      assert(maybeSpec, `Node type ${type} must be defined`);
+      const spec = clone(maybeSpec);
       if (!spec.attrs) {
         spec.attrs = {};
       }
-      spec.attrs[attr] = {
-        default: defaultValue,
-        splittable
-      };
-      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],
-                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;
+      for (const attr of attrs) {
+        spec.attrs[attr.attr] = {
+          default: attr.default,
+          validate: attr.validate,
+          splittable: attr.splittable
         };
       }
-      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
-            };
-          };
-        }
+      if (spec.toDOM) {
+        spec.toDOM = wrapOutputSpecAttrs(spec.toDOM, attrs);
       }
+      if (spec.parseDOM) {
+        spec.parseDOM = spec.parseDOM.map(
+          (rule) => wrapTagParseRuleAttrs(rule, attrs)
+        );
+      }
+      specs = specs.update(type, spec);
     }
     return { nodes: specs, topNode: topNodeName };
   },
   parent: schemaSpecFacet,
   singleton: true
 });
-function setObjectAttribute(obj, key, value) {
-  if (key === "style") {
-    value = `${value}${obj.style || ""}`;
-  }
-  return { ...obj, [key]: value };
-}
-function setElementAttribute(element, key, value) {
-  if (key === "style") {
-    value = `${value}${element.getAttribute("style") || ""}`;
-  }
-  element.setAttribute(key, value);
-}
 
 // src/extensions/doc.ts
 function defineDoc() {
@@ -653,23 +697,25 @@ function defineDoc() {
 }
 
 // src/extensions/events/plugin-view.ts
-import { PluginKey, ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm/state";
+import {
+  PluginKey,
+  ProseMirrorPlugin
+} from "@prosekit/pm/state";
 
 // src/extensions/plugin.ts
-import "@prosekit/pm/model";
 import { Plugin } from "@prosekit/pm/state";
 function definePlugin(plugin) {
-  if (plugin instanceof Plugin) {
-    return defineFacetPayload(pluginFacet, [() => [plugin]]);
-  }
-  if (Array.isArray(plugin) && plugin.every((p) => p instanceof Plugin)) {
-    return defineFacetPayload(pluginFacet, [() => plugin]);
+  if (plugin instanceof Plugin || Array.isArray(plugin) && plugin.every((p) => p instanceof Plugin)) {
+    return definePluginPayload(() => plugin);
   }
   if (typeof plugin === "function") {
-    return defineFacetPayload(pluginFacet, [plugin]);
+    return definePluginPayload(plugin);
   }
   throw new TypeError("Invalid plugin");
 }
+function definePluginPayload(payload) {
+  return defineFacetPayload(pluginFacet, [payload]);
+}
 var pluginFacet = defineFacet({
   reducer: (payloads) => {
     return ({ schema }) => {
@@ -694,20 +740,23 @@ var pluginFacet = defineFacet({
 
 // src/extensions/events/plugin-view.ts
 function defineMountHandler(handler) {
-  return defineFacetPayload(pluginViewFacet, [["mount", handler]]);
+  return definePluginViewFacetPayload(["mount", handler]);
 }
 function defineUpdateHandler(handler) {
-  return defineFacetPayload(pluginViewFacet, [["update", handler]]);
+  return definePluginViewFacetPayload(["update", handler]);
 }
 function defineUnmountHandler(handler) {
-  return defineFacetPayload(pluginViewFacet, [["unmount", handler]]);
+  return definePluginViewFacetPayload(["unmount", handler]);
+}
+function definePluginViewFacetPayload(input) {
+  return defineFacetPayload(pluginViewFacet, [input]);
 }
 var pluginViewFacet = defineFacet({
   reduce: () => {
     let mountHandlers = [];
     let updateHandlers = [];
     let unmountHandlers = [];
-    const plugin = new ProseMirrorPlugin2({
+    const plugin = new ProseMirrorPlugin({
       key: pluginKey,
       view: (view) => {
         mountHandlers.forEach((fn) => fn(view));
@@ -759,16 +808,16 @@ function defineDocChangeHandler(handler) {
 }
 
 // src/extensions/events/dom-event.ts
-import { PluginKey as PluginKey2, ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
+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 = toReversed(handlers);
+  let handlers = [];
+  function setHandlers(eventHandlers) {
+    handlers = toReversed(eventHandlers);
   }
   function combinedEventHandler(...args) {
-    for (const handler of _handlers) {
+    for (const handler of handlers) {
       if (handler(...args)) {
         return true;
       }
@@ -778,20 +827,6 @@ function combineEventHandlers() {
   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 defineFacetPayload(domEventFacet, [
@@ -823,7 +858,7 @@ var domEventFacet = defineFacet({
         setHandlers(handlers);
       }
       if (hasNewEvent) {
-        plugin = new ProseMirrorPlugin3({
+        plugin = new ProseMirrorPlugin2({
           key: new PluginKey2("prosekit-dom-event-handler"),
           props: { handleDOMEvents: combinedHandlerMap }
         });
@@ -839,7 +874,7 @@ var domEventFacet = defineFacet({
 });
 
 // src/extensions/events/editor-event.ts
-import { PluginKey as PluginKey3, ProseMirrorPlugin as ProseMirrorPlugin4 } from "@prosekit/pm/state";
+import { PluginKey as PluginKey3, ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
 function defineKeyDownHandler(handler) {
   return defineFacetPayload(editorEventFacet, [["keyDown", handler]]);
 }
@@ -916,7 +951,7 @@ function setupEditorEventPlugin() {
     setDropHandlers((_k = map.drop) != null ? _k : []);
     setScrollToSelectionHandlers((_l = map.scrollToSelection) != null ? _l : []);
   };
-  const plugin = new ProseMirrorPlugin4({
+  const plugin = new ProseMirrorPlugin3({
     key: new PluginKey3("prosekit-editor-event"),
     props: {
       handleKeyDown,
@@ -956,6 +991,7 @@ var isApple = typeof navigator !== "undefined" ? /Mac|iP(hone|[ao]d)/.test(navig
 import { chainCommands } from "@prosekit/pm/commands";
 import { keydownHandler } from "@prosekit/pm/keymap";
 import { Plugin as Plugin2, PluginKey as PluginKey4 } from "@prosekit/pm/state";
+import mapValues from "just-map-values";
 function defineKeymap(keymap2) {
   return defineFacetPayload(keymapFacet, [keymap2]);
 }
@@ -991,12 +1027,10 @@ function mergeKeymaps(keymaps) {
       commands2.push(command);
     }
   }
-  return Object.fromEntries(
-    Object.entries(bindings).map(([key, commands2]) => [
-      key,
-      chainCommands(...commands2)
-    ])
-  );
+  return mapValues(bindings, mergeCommands);
+}
+function mergeCommands(commands2) {
+  return chainCommands(...commands2);
 }
 var keymapPluginKey = new PluginKey4("prosekit-keymap");
 
@@ -1016,11 +1050,11 @@ function defineHistory({
   depth = 200,
   newGroupDelay = 250
 } = {}) {
-  return union([
+  return union(
     definePlugin(history({ depth, newGroupDelay })),
     defineKeymap(keymap),
     defineCommands(commands)
-  ]);
+  );
 }
 
 // src/extensions/keymap-base.ts
@@ -1061,6 +1095,7 @@ function defineBaseKeymap(options) {
 }
 
 // src/extensions/mark-spec.ts
+import clone2 from "just-clone";
 import OrderedMap3 from "orderedmap";
 function defineMarkSpec(options) {
   const payload = [options, void 0];
@@ -1073,81 +1108,55 @@ function defineMarkAttr(options) {
 var markSpecFacet = defineFacet({
   reducer: (payloads) => {
     let specs = OrderedMap3.from({});
-    const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
-    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
+    const specPayloads = payloads.map((input) => input[0]).filter(isNotNullish);
+    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNullish);
     for (const { name, ...spec } of specPayloads) {
-      assert(!specs.get(name), `Mark type ${name} can only be defined once`);
-      specs = specs.addToStart(name, spec);
+      const prevSpec = specs.get(name);
+      if (prevSpec) {
+        specs = specs.update(name, mergeSpecs(prevSpec, spec));
+      } else {
+        specs = specs.addToStart(name, spec);
+      }
     }
-    for (const {
-      type,
-      attr,
-      default: defaultValue,
-      toDOM,
-      parseDOM
-    } of attrPayloads) {
-      const spec = specs.get(type);
-      assert(spec, `Mark type ${type} must be defined`);
+    const groupedAttrs = groupBy(attrPayloads, (payload) => payload.type);
+    for (const [type, attrs] of Object.entries(groupedAttrs)) {
+      if (!attrs) continue;
+      const maybeSpec = specs.get(type);
+      assert(maybeSpec, `Mark type ${type} must be defined`);
+      const spec = clone2(maybeSpec);
       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;
+      for (const attr of attrs) {
+        spec.attrs[attr.attr] = {
+          default: attr.default,
+          validate: attr.validate
         };
       }
-      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
-            };
-          };
-        }
+      if (spec.toDOM) {
+        spec.toDOM = wrapOutputSpecAttrs(spec.toDOM, attrs);
+      }
+      if (spec.parseDOM) {
+        spec.parseDOM = spec.parseDOM.map(
+          (rule) => wrapParseRuleAttrs(rule, attrs)
+        );
       }
+      specs = specs.update(type, spec);
     }
     return { marks: specs, nodes: {} };
   },
   parent: schemaSpecFacet,
   singleton: true
 });
+function wrapParseRuleAttrs(rule, attrs) {
+  if (rule.tag) {
+    return wrapTagParseRuleAttrs(rule, attrs);
+  }
+  return rule;
+}
 
 // src/extensions/node-view.ts
-import { PluginKey as PluginKey5, ProseMirrorPlugin as ProseMirrorPlugin5 } from "@prosekit/pm/state";
+import { PluginKey as PluginKey5, ProseMirrorPlugin as ProseMirrorPlugin4 } from "@prosekit/pm/state";
 function defineNodeView(options) {
   return defineFacetPayload(nodeViewFacet, [options]);
 }
@@ -1160,7 +1169,7 @@ var nodeViewFacet = defineFacet({
       }
     }
     return () => [
-      new ProseMirrorPlugin5({
+      new ProseMirrorPlugin4({
         key: new PluginKey5("prosekit-node-view"),
         props: { nodeViews }
       })
@@ -1170,7 +1179,7 @@ var nodeViewFacet = defineFacet({
 });
 
 // src/extensions/node-view-effect.ts
-import { PluginKey as PluginKey6, ProseMirrorPlugin as ProseMirrorPlugin6 } from "@prosekit/pm/state";
+import { PluginKey as PluginKey6, ProseMirrorPlugin as ProseMirrorPlugin5 } from "@prosekit/pm/state";
 function defineNodeViewFactory(options) {
   const input = [options, null];
   return defineFacetPayload(nodeViewFactoryFacet, [input]);
@@ -1184,15 +1193,15 @@ var nodeViewFactoryFacet = defineFacet({
   reducer: (inputs) => {
     if (isServer) return [];
     const nodeViews = {};
-    const factories = inputs.map((x) => x[0]).filter(isNotNull);
-    const options = inputs.map((x) => x[1]).filter(isNotNull);
+    const factories = inputs.map((x) => x[0]).filter(isNotNullish);
+    const options = inputs.map((x) => x[1]).filter(isNotNullish);
     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({
+      new ProseMirrorPlugin5({
         key: new PluginKey6("prosekit-node-view-effect"),
         props: { nodeViews }
       })
@@ -1240,7 +1249,7 @@ function cache(fn) {
 var canUseRegexLookbehind = cache(() => {
   try {
     return "ab".replace(new RegExp("(?<=a)b", "g"), "c") === "ac";
-  } catch (error) {
+  } catch (e) {
     return false;
   }
 });
@@ -1249,13 +1258,22 @@ var canUseRegexLookbehind = cache(() => {
 import clsxLite from "clsx/lite";
 var clsx = clsxLite;
 
+// src/utils/collect-children.ts
+function collectChildren(parent) {
+  const children = [];
+  for (let i = 0; i < parent.childCount; i++) {
+    children.push(parent.child(i));
+  }
+  return children;
+}
+
 // src/utils/collect-nodes.ts
-import { ProseMirrorFragment, ProseMirrorNode as ProseMirrorNode2 } from "@prosekit/pm/model";
+import { ProseMirrorFragment, ProseMirrorNode } from "@prosekit/pm/model";
 function collectNodes(content) {
   if (Array.isArray(content)) {
     return content.flatMap(collectNodes);
   }
-  if (content instanceof ProseMirrorNode2) {
+  if (content instanceof ProseMirrorNode) {
     return [content];
   }
   if (content instanceof ProseMirrorFragment) {
@@ -1278,15 +1296,6 @@ function containsInlineNode(doc, from, to) {
   return found;
 }
 
-// src/utils/default-block-at.ts
-function defaultBlockAt(match) {
-  for (let i = 0; i < match.edgeCount; i++) {
-    const { type } = match.edge(i);
-    if (type.isTextblock && !type.hasRequiredAttrs()) return type;
-  }
-  return null;
-}
-
 // src/utils/get-id.ts
 var id = 0;
 function getId() {
@@ -1338,6 +1347,7 @@ export {
   assert,
   canUseRegexLookbehind,
   clsx,
+  collectChildren,
   collectNodes,
   containsInlineNode,
   createEditor,
@@ -1382,20 +1392,26 @@ export {
   elementFromJSON,
   elementFromNode,
   expandMark,
+  findParentNode,
+  findParentNodeOfType,
   getMarkType,
   getNodeType,
   htmlFromJSON,
   htmlFromNode,
+  insertDefaultBlock,
   insertNode,
   isAllSelection,
   isApple,
   isAtBlockStart,
+  isFragment,
   isInCodeBlock,
   isMark,
   isMarkAbsent,
   isMarkActive,
   isNodeSelection,
   isProseMirrorNode,
+  isSelection,
+  isSlice,
   isTextSelection,
   jsonFromHTML,
   jsonFromNode,