@prosekit/core 0.4.1 → 0.5.0

package/dist/prosekit-core.js

@@ -107,6 +107,13 @@ function expandMarkAfter($pos, predicate) {
 import "@prosekit/pm/state";
 import { insertPoint } from "@prosekit/pm/transform";
 
+// src/utils/assert.ts
+function assert(condition, message = "Assertion failed") {
+  if (!condition) {
+    throw new ProseKitError(message);
+  }
+}
+
 // src/utils/get-node-type.ts
 import "@prosekit/pm/model";
 function getNodeType(schema, type) {
@@ -133,10 +140,8 @@ function setSelectionAround(tr, pos) {
 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 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");
     const insertPos = insertPoint(
       state.doc,
       (_a = options.pos) != null ? _a : state.selection.to,
@@ -228,20 +233,38 @@ 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));
+  }
+  return [getNodeType(schema, types)];
+}
+
 // 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) {
+    var _a, _b;
+    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) {
       const { tr } = state;
-      for (const [key, value] of Object.entries(options.attrs)) {
-        if (value !== void 0) {
+      for (const pos of positions) {
+        for (const [key, value] of Object.entries(options.attrs)) {
           tr.setNodeAttribute(pos, key, value);
         }
       }
@@ -252,19 +275,85 @@ function setNodeAttrs(options) {
 }
 
 // src/commands/toggle-mark.ts
-import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
 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
 }) {
   return (state, dispatch, view) => {
-    return baseToggleMark(getMarkType(state.schema, type), attrs)(
-      state,
-      dispatch,
-      view
-    );
+    return baseToggleMark(getMarkType(state.schema, type), attrs, {
+      removeWhenPresent: false
+    })(state, dispatch, view);
   };
 }
 
@@ -317,14 +406,27 @@ function toggleNode({
 }
 
 // src/editor/editor.ts
-import { Schema as Schema6 } from "@prosekit/pm/model";
+import "@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
+// src/types/priority.ts
+var Priority = /* @__PURE__ */ ((Priority2) => {
+  Priority2[Priority2["lowest"] = 0] = "lowest";
+  Priority2[Priority2["low"] = 1] = "low";
+  Priority2[Priority2["default"] = 2] = "default";
+  Priority2[Priority2["high"] = 3] = "high";
+  Priority2[Priority2["highest"] = 4] = "highest";
+  return Priority2;
+})(Priority || {});
+
+// src/facets/base-extension.ts
+import "@prosekit/pm/model";
+
+// src/utils/array.ts
 function uniqPush(prev, next) {
   const result = [...prev];
   for (const item of next) {
@@ -334,84 +436,268 @@ function uniqPush(prev, next) {
   }
   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 result;
+function arraySubstract(a, b) {
+  return a.filter((x) => !b.includes(x));
+}
+function toReversed(arr) {
+  var _a, _b;
+  return (_b = (_a = arr.toReversed) == null ? void 0 : _a.call(arr)) != null ? _b : [...arr].reverse();
 }
 
-// src/facets/base-extension.ts
-import "@prosekit/pm/model";
-var BaseExtension = class {
-  constructor() {
-    this.extension = [];
+// src/facets/facet-node.ts
+function zip5(a, b, mapper) {
+  return [
+    mapper(a[0], b[0]),
+    mapper(a[1], b[1]),
+    mapper(a[2], b[2]),
+    mapper(a[3], b[3]),
+    mapper(a[4], b[4])
+  ];
+}
+function unionInput(a, b) {
+  if (!a && !b)
+    return null;
+  return uniqPush(a != null ? a : [], b != null ? b : []);
+}
+function subtractInput(a, b) {
+  if (!a)
+    return null;
+  if (!b)
+    return [];
+  return arraySubstract(a, b);
+}
+function unionChildren(a, b) {
+  const merged = new Map(a);
+  for (const [key, valueB] of b.entries()) {
+    const valueA = a.get(key);
+    merged.set(key, valueA ? unionFacetNode(valueA, valueB) : valueB);
+  }
+  return merged;
+}
+function subtractChildren(a, b) {
+  const merged = new Map(a);
+  for (const [key, valueB] of b.entries()) {
+    const valueA = a.get(key);
+    merged.set(key, valueA ? subtractFacetNode(valueA, valueB) : valueB);
+  }
+  return merged;
+}
+function unionFacetNode(a, b) {
+  assert(a.facet === b.facet);
+  return new FacetNode(
+    a.facet,
+    zip5(a.inputs, b.inputs, unionInput),
+    unionChildren(a.children, b.children)
+  );
+}
+function subtractFacetNode(a, b) {
+  assert(a.facet === b.facet);
+  return new FacetNode(
+    a.facet,
+    zip5(a.inputs, b.inputs, subtractInput),
+    subtractChildren(a.children, b.children)
+  );
+}
+var FacetNode = class {
+  constructor(facet, inputs = [null, null, null, null, null], children = /* @__PURE__ */ new Map()) {
+    this.facet = facet;
+    this.inputs = inputs;
+    this.children = children;
+    this.reducers = [null, null, null, null, null];
+    this.output = null;
+  }
+  calcOutput() {
+    var _a, _b, _c;
+    const inputs = [null, null, null, null, null];
+    const output = [null, null, null, null, null];
+    for (let pri = 0; pri < 5; pri++) {
+      const input = this.inputs[pri];
+      if (input) {
+        inputs[pri] = [...input];
+      }
+    }
+    for (const child of this.children.values()) {
+      const childOutput = child.getOutput();
+      for (let pri = 0; pri < 5; pri++) {
+        if (childOutput[pri]) {
+          const input = inputs[pri] || (inputs[pri] = []);
+          input.push(childOutput[pri]);
+        }
+      }
+    }
+    if (this.facet.singleton) {
+      const reducer = (_a = this.reducers)[_b = 2 /* default */] || (_a[_b] = this.facet.reducer);
+      const input = inputs.filter(Boolean).flat();
+      output[2 /* default */] = reducer(input);
+    } else {
+      for (let pri = 0; pri < 5; pri++) {
+        const input = inputs[pri];
+        if (input) {
+          const reducer = (_c = this.reducers)[pri] || (_c[pri] = this.facet.reducer);
+          output[pri] = reducer(input);
+        }
+      }
+    }
+    return output;
+  }
+  getOutput() {
+    if (!this.output) {
+      this.output = this.calcOutput();
+    }
+    return this.output;
+  }
+  getSingletonOutput() {
+    assert(this.facet.singleton);
+    return this.getOutput()[2 /* default */];
+  }
+  getRootOutput() {
+    assert(this.isRoot());
+    const output = this.getSingletonOutput();
+    assert(output);
+    return output;
+  }
+  isRoot() {
+    return !this.facet.parent;
   }
 };
 
+// src/facets/schema.ts
+import { Schema as Schema4 } from "@prosekit/pm/model";
+
 // src/facets/facet.ts
 var facetCount = 0;
-function getFacetCount() {
-  return facetCount;
-}
-var Facet = class _Facet {
-  constructor(converter, next, singleton) {
+var Facet = class {
+  /**
+   * @internal
+   */
+  constructor(parent, singleton, _reducer, _reduce) {
+    this._reducer = _reducer;
+    this._reduce = _reduce;
     /**
      * @internal
      */
     this.index = facetCount++;
-    /**
-     * @internal
-     */
-    this.isSchema = false;
-    this.converter = converter;
-    this.next = next;
+    assert((_reduce || _reducer) && !(_reduce && _reducer));
+    this.parent = parent;
     this.singleton = singleton;
+    this.path = parent ? [...parent.path, this.index] : [];
   }
-  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 new _Facet(converterFunction, next, singleton != null ? singleton : false);
+  get reducer() {
+    var _a, _b;
+    return (_b = this._reducer) != null ? _b : (_a = this._reduce) == null ? void 0 : _a.call(this);
+  }
+};
+function defineFacet(options) {
+  var _a;
+  return new Facet(
+    options.parent,
+    (_a = options.singleton) != null ? _a : false,
+    options.reducer,
+    options.reduce
+  );
+}
+
+// src/facets/root.ts
+function rootReducer(inputs) {
+  var _a;
+  let schema;
+  let commands;
+  let stateFunc;
+  let view;
+  for (const input of inputs) {
+    schema = input.schema || schema;
+    commands = input.commands || commands;
+    stateFunc = input.state || stateFunc;
+    view = input.view || view;
+  }
+  const state = schema && ((_a = stateFunc == null ? void 0 : stateFunc({ schema })) != null ? _a : { schema });
+  return { schema, state, commands, view };
+}
+var rootFacet = new Facet(
+  null,
+  true,
+  rootReducer
+);
+
+// src/facets/schema.ts
+var schemaFacet = defineFacet({
+  reducer: (specs) => {
+    assert(specs.length <= 1);
+    const spec = specs[0];
+    const schema = spec ? new Schema4(spec) : null;
+    return { schema };
+  },
+  parent: rootFacet,
+  singleton: true
+});
+
+// src/facets/base-extension.ts
+var BaseExtension = class {
+  constructor() {
+    this.extension = [];
+    this.trees = [null, null, null, null, null];
   }
   /**
    * @internal
    */
-  static defineRootFacet(options) {
-    return _Facet.define(options);
+  getTree(priority) {
+    var _a, _b;
+    const pri = (_a = priority != null ? priority : this.priority) != null ? _a : 2 /* default */;
+    return (_b = this.trees)[pri] || (_b[pri] = this.createTree(pri));
   }
-  extension(payloads) {
-    return new FacetExtensionImpl(this, payloads);
+  /**
+   * @internal
+   */
+  findFacetOutput(facet) {
+    var _a;
+    let node = this.getTree();
+    for (const index of facet.path) {
+      node = node == null ? void 0 : node.children.get(index);
+    }
+    return (_a = node == null ? void 0 : node.getOutput()) != null ? _a : null;
+  }
+  get schema() {
+    var _a, _b;
+    const output = this.findFacetOutput(schemaFacet);
+    return (_b = (_a = output == null ? void 0 : output.find(Boolean)) == null ? void 0 : _a.schema) != null ? _b : null;
   }
 };
+
+// src/facets/facet-extension.ts
 var FacetExtensionImpl = class extends BaseExtension {
+  /**
+   * @internal
+   */
   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));
+  }
+  /**
+   * @internal
+   */
+  createTree(priority) {
+    var _a;
+    const pri = (_a = this.priority) != null ? _a : priority;
+    const inputs = [null, null, null, null, null];
+    inputs[pri] = [...this.payloads];
+    let node = new FacetNode(this.facet, inputs);
+    while (node.facet.parent) {
+      const children = /* @__PURE__ */ new Map([[node.facet.index, node]]);
+      node = new FacetNode(node.facet.parent, void 0, children);
+    }
+    return node;
   }
 };
+function defineFacetPayload(facet, payloads) {
+  return new FacetExtensionImpl(facet, payloads);
+}
 
 // src/facets/state.ts
-var stateFacet = Facet.defineRootFacet({
-  convert: (callbacks) => {
-    return (ctx) => {
+var stateFacet = defineFacet({
+  reduce: () => {
+    let callbacks = [];
+    const state = (ctx) => {
       var _a, _b, _c, _d, _e, _f;
       const configs = callbacks.map((cb) => cb(ctx));
       const config = {
@@ -426,17 +712,22 @@ var stateFacet = Facet.defineRootFacet({
         config.storedMarks = [...config.storedMarks, ...(_d = c.storedMarks) != null ? _d : []];
         config.plugins = uniqPush((_e = config.plugins) != null ? _e : [], (_f = c.plugins) != null ? _f : []);
       }
-      if (!config.doc && !config.schema) {
-        throw new ProseKitError(
-          "Can't create state without a schema nor a document"
-        );
-      }
+      assert(
+        config.doc || config.schema,
+        "Can't create state without a schema nor a document"
+      );
       if (config.doc) {
         config.schema = void 0;
       }
       return config;
     };
-  }
+    return function reducer(inputs) {
+      callbacks = inputs;
+      return { state };
+    };
+  },
+  singleton: true,
+  parent: rootFacet
 });
 
 // src/utils/parse.ts
@@ -552,7 +843,7 @@ function defineDefaultState({
       "Only one of defaultHTML and defaultDoc can be provided"
     );
   }
-  return stateFacet.extension([
+  return defineFacetPayload(stateFacet, [
     ({ schema }) => {
       const config = {};
       if (defaultHTML) {
@@ -573,225 +864,44 @@ function defineDefaultState({
   ]);
 }
 
-// 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/facets/schema.ts
+// src/utils/deep-equals.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 };
+function deepEquals(a, b) {
+  if (a === b) {
+    return true;
   }
-});
-schemaFacet.isSchema = true;
-
-// src/facets/view.ts
-var viewFacet = Facet.defineRootFacet({
-  convert: (props) => {
-    return Object.assign({}, ...props);
+  if (!a || !b) {
+    return false;
   }
-});
-
-// 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 payloads = [];
-  while (extensions.length > 0) {
-    const ext = extensions.pop();
-    const pri = priorities.pop();
-    if (ext instanceof FacetExtensionImpl) {
-      const facet = ext.facet;
-      if (!facets[facet.index]) {
-        facets[facet.index] = facet;
-        payloads[facet.index] = [[], [], [], [], []];
-      }
-      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)) {
-        for (const e of ext.extension) {
-          extensions.push(e);
-          priorities.push(p);
-        }
-      } else {
-        extensions.push(ext.extension);
-        priorities.push(p);
-      }
-    } else {
-      throw new ProseKitError("Invalid extension");
-    }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((x, i) => deepEquals(x, b[i]));
   }
-  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;
-  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 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);
-      }
-      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");
-        }
-      }
-    }
+  if (a instanceof OrderedMap && b instanceof OrderedMap) {
+    return a.size === b.size && deepEquals(a.toObject(), b.toObject());
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    return aKeys.length === bKeys.length && aKeys.every((key) => deepEquals(a[key], b[key]));
   }
-  return { schemaInput, stateInput, viewInput, commandInput };
+  return false;
 }
 
 // src/editor/builder.ts
 import "@prosekit/pm/model";
 
+// src/utils/is-mark-absent.ts
+function isMarkAbsent(node, from, to, markType, attrs) {
+  const mark = attrs ? markType.create(attrs) : markType;
+  let missing = false;
+  node.nodesBetween(from, to, (node2, pos, parent) => {
+    if (missing)
+      return false;
+    missing = !mark.isInSet(node2.marks) && !!parent && parent.type.allowsMarkType(markType);
+  });
+  return missing;
+}
+
 // src/utils/is-mark-active.ts
 function isMarkActive(state, type, attrs) {
   const { from, $from, to, empty } = state.selection;
@@ -800,26 +910,25 @@ function isMarkActive(state, type, attrs) {
     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);
+    return !isMarkAbsent(state.doc, from, to, markType, attrs);
   }
 }
 
 // src/utils/type-assertion.ts
-import { Mark, ProseMirrorNode } from "@prosekit/pm/model";
+import { Mark, ProseMirrorNode as ProseMirrorNode2 } from "@prosekit/pm/model";
 import {
   AllSelection,
   NodeSelection,
-  TextSelection as TextSelection4
+  TextSelection as TextSelection5
 } from "@prosekit/pm/state";
 function isProseMirrorNode(node) {
-  return node instanceof ProseMirrorNode;
+  return node instanceof ProseMirrorNode2;
 }
 function isMark(mark) {
   return mark instanceof Mark;
 }
 function isTextSelection(sel) {
-  return sel instanceof TextSelection4;
+  return sel instanceof TextSelection5;
 }
 function isNodeSelection(sel) {
   return sel instanceof NodeSelection;
@@ -893,43 +1002,27 @@ function isNodeChild(value) {
 }
 
 // src/facets/union-extension.ts
-import { Schema as Schema5 } from "@prosekit/pm/model";
 var UnionExtensionImpl = class extends BaseExtension {
+  /**
+   * @internal
+   */
   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");
-      }
-    }
-  }
-  get hasSchema() {
-    return this.hasSchemaCount > 0;
   }
-  get schema() {
+  /**
+   * @internal
+   */
+  createTree(priority) {
     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;
+    const pri = (_a = this.priority) != null ? _a : priority;
+    const extensions = [...this.extension];
+    extensions.sort((a, b) => {
+      var _a2, _b;
+      return ((_a2 = a.priority) != null ? _a2 : pri) - ((_b = b.priority) != null ? _b : pri);
+    });
+    const children = extensions.map((ext) => ext.getTree(pri));
+    return children.reduce(unionFacetNode, new FacetNode(rootFacet));
   }
 };
 
@@ -961,24 +1054,21 @@ var EditorInstance = class {
   constructor(extension) {
     this.view = null;
     this.commandAppliers = {};
-    this.payloads = [];
-    this.converters = [];
     this.mount = this.mount.bind(this);
     this.unmount = this.unmount.bind(this);
-    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 };
+    this.tree = extension.getTree();
+    const payload = this.tree.getRootOutput();
+    const schema = payload.schema;
+    const stateConfig = payload.state;
+    assert(schema && stateConfig, "Schema must be defined");
     const state = EditorState2.create(stateConfig);
     this.cachedState = state;
-    if (commandInput) {
-      for (const [name, commandCreator] of Object.entries(commandInput)) {
+    if (payload.commands) {
+      for (const [name, commandCreator] of Object.entries(payload.commands)) {
         this.defineCommand(name, commandCreator);
       }
     }
-    this.directEditorProps = { state, ...viewInput };
+    this.directEditorProps = { state, ...payload.view };
     this.schema = this.directEditorProps.state.schema;
     const getState = () => this.getState();
     this.nodeBuilders = Object.fromEntries(
@@ -1000,29 +1090,31 @@ var EditorInstance = class {
     }
     return this.cachedState;
   }
-  updateExtension(extension, mode) {
-    var _a;
-    const { schemaInput, stateInput, viewInput, commandInput } = updateExtension(this.payloads, this.converters, extension, mode);
-    if (schemaInput) {
+  updateExtension(extension, add) {
+    var _a, _b, _c, _d, _e;
+    const tree = extension.getTree();
+    const payload = tree.getRootOutput();
+    if (payload == null ? void 0 : payload.schema) {
       throw new ProseKitError("Schema cannot be changed");
     }
-    if (viewInput) {
+    if (payload == null ? void 0 : payload.view) {
       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 });
+    const oldPayload = this.tree.getRootOutput();
+    const oldPlugins = [...(_c = (_b = (_a = this.view) == null ? void 0 : _a.state) == null ? void 0 : _b.plugins) != null ? _c : []];
+    this.tree = add ? unionFacetNode(this.tree, tree) : subtractFacetNode(this.tree, tree);
+    const newPayload = this.tree.getRootOutput();
+    const newPlugins = [...(_e = (_d = newPayload == null ? void 0 : newPayload.state) == null ? void 0 : _d.plugins) != null ? _e : []];
+    if (!deepEquals(oldPlugins, newPlugins)) {
+      assert(this.view, "EditorInstance.view is not defined");
+      const state = this.view.state.reconfigure({ plugins: newPlugins });
       this.view.updateState(state);
     }
-    if (commandInput) {
-      const names = Object.keys(commandInput);
+    if ((newPayload == null ? void 0 : newPayload.commands) && !deepEquals(oldPayload == null ? void 0 : oldPayload.commands, newPayload == null ? void 0 : newPayload.commands)) {
+      const commands = newPayload.commands;
+      const names = Object.keys(commands);
       for (const name of names) {
-        this.defineCommand(name, commandInput[name]);
+        this.defineCommand(name, commands[name]);
       }
     }
   }
@@ -1176,8 +1268,8 @@ var Editor = class _Editor {
         lazyRemove == null ? void 0 : lazyRemove();
       };
     }
-    this.instance.updateExtension(extension, "add");
-    return () => this.instance.updateExtension(extension, "remove");
+    this.instance.updateExtension(extension, true);
+    return () => this.instance.updateExtension(extension, false);
   }
   get state() {
     return this.instance.getState();
@@ -1241,9 +1333,19 @@ function wrap({
   };
 }
 
+// src/facets/command.ts
+var commandFacet = defineFacet({
+  reducer: (inputs) => {
+    const commands = Object.assign({}, ...inputs);
+    return { commands };
+  },
+  parent: rootFacet,
+  singleton: true
+});
+
 // src/extensions/command.ts
 function defineCommands(commands) {
-  return commandFacet.extension([commands]);
+  return defineFacetPayload(commandFacet, [commands]);
 }
 function defineBaseCommands() {
   return defineCommands({
@@ -1258,6 +1360,29 @@ function defineBaseCommands() {
   });
 }
 
+// src/extensions/node-spec.ts
+import OrderedMap3 from "orderedmap";
+
+// src/facets/schema-spec.ts
+import "@prosekit/pm/model";
+import OrderedMap2 from "orderedmap";
+var schemaSpecFacet = defineFacet({
+  reducer: (specs) => {
+    var _a;
+    let nodes = OrderedMap2.from({});
+    let marks = OrderedMap2.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: true
+});
+
 // src/utils/is-element.ts
 var hasElement = typeof Element !== "undefined";
 function isElement(value) {
@@ -1272,44 +1397,39 @@ function isNotNull(value) {
 // src/extensions/node-spec.ts
 function defineNodeSpec(options) {
   const payload = [options, void 0];
-  return nodeSpecFacet.extension([payload]);
+  return defineFacetPayload(nodeSpecFacet, [payload]);
 }
 function defineNodeAttr(options) {
   const payload = [void 0, options];
-  return nodeSpecFacet.extension([payload]);
+  return defineFacetPayload(nodeSpecFacet, [payload]);
 }
-var nodeSpecFacet = Facet.define({
-  convert: (payloads) => {
-    const nodes = {};
+var nodeSpecFacet = defineFacet({
+  reducer: (payloads) => {
+    let nodes = OrderedMap3.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) {
-      if (nodes[name]) {
-        throw new ProseKitError(`Node type ${name} has already been defined`);
-      }
+      assert(!nodes.get(name), `Node type ${name} can only be defined once`);
       if (topNode) {
         topNodeName = name;
       }
-      nodes[name] = spec;
+      nodes = nodes.addToStart(name, spec);
     }
     for (const {
       type,
       attr,
       default: defaultValue,
+      splittable,
       toDOM,
       parseDOM
     } of attrPayloads) {
-      const spec = nodes[type];
-      if (!spec) {
-        throw new ProseKitError(
-          `Node type ${type} must be defined before defining attributes`
-        );
-      }
+      const spec = nodes.get(type);
+      assert(spec, `Node type ${type} must be defined`);
       if (!spec.attrs) {
         spec.attrs = {};
       }
-      spec.attrs[attr] = { default: defaultValue };
+      spec.attrs[attr] = { default: defaultValue, splittable };
       if (toDOM && spec.toDOM) {
         const existingToDom = spec.toDOM;
         spec.toDOM = (node) => {
@@ -1327,14 +1447,22 @@ var nodeSpecFacet = Facet.define({
           }
           if (Array.isArray(dom)) {
             if (typeof dom[1] === "object") {
-              return [dom[0], { ...dom[1], [key]: value }, ...dom.slice(2)];
+              return [
+                dom[0],
+                setObjectAttribute(
+                  dom[1],
+                  key,
+                  value
+                ),
+                ...dom.slice(2)
+              ];
             } else {
               return [dom[0], { [key]: value }, ...dom.slice(1)];
             }
           } else if (isElement(dom)) {
-            dom.setAttribute(key, value);
+            setElementAttribute(dom, key, value);
           } else if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
-            dom.dom.setAttribute(key, value);
+            setElementAttribute(dom.dom, key, value);
           }
           return dom;
         };
@@ -1360,9 +1488,21 @@ var nodeSpecFacet = Facet.define({
     }
     return { nodes, topNode: topNodeName };
   },
-  next: schemaFacet,
+  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() {
@@ -1374,60 +1514,61 @@ function defineDoc() {
 }
 
 // src/extensions/events/plugin-view.ts
-import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
+import { PluginKey, ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm/state";
 
 // src/extensions/plugin.ts
 import "@prosekit/pm/model";
 import { Plugin as Plugin2 } from "@prosekit/pm/state";
 function definePlugin(plugin) {
   if (plugin instanceof Plugin2) {
-    return pluginFacet.extension([() => [plugin]]);
+    return defineFacetPayload(pluginFacet, [() => [plugin]]);
   }
   if (Array.isArray(plugin) && plugin.every((p) => p instanceof Plugin2)) {
-    return pluginFacet.extension([() => plugin]);
+    return defineFacetPayload(pluginFacet, [() => plugin]);
   }
   if (typeof plugin === "function") {
-    return pluginFacet.extension([plugin]);
+    return defineFacetPayload(pluginFacet, [plugin]);
   }
   throw new TypeError("Invalid plugin");
 }
-var pluginFacet = Facet.define({
-  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;
+var pluginFacet = defineFacet({
+  reducer: (payloads) => {
+    return ({ schema }) => {
+      const plugins = [];
+      for (const payload of payloads) {
+        if (payload instanceof Plugin2) {
+          plugins.push(payload);
+        } else if (Array.isArray(payload) && payload.every((p) => p instanceof Plugin2)) {
+          plugins.push(...payload);
+        } else if (typeof payload === "function") {
+          plugins.push(...[payload({ schema })].flat());
+        } else {
+          throw new ProseKitError("Invalid plugin");
+        }
       }
+      plugins.reverse();
+      return { plugins };
     };
   },
-  next: stateFacet
+  parent: stateFacet
 });
 
 // src/extensions/events/plugin-view.ts
 function defineMountHandler(handler) {
-  return pluginViewFacet.extension([["mount", handler]]);
+  return defineFacetPayload(pluginViewFacet, [["mount", handler]]);
 }
 function defineUpdateHandler(handler) {
-  return pluginViewFacet.extension([["update", handler]]);
+  return defineFacetPayload(pluginViewFacet, [["update", handler]]);
 }
 function defineUnmountHandler(handler) {
-  return pluginViewFacet.extension([["unmount", handler]]);
+  return defineFacetPayload(pluginViewFacet, [["unmount", handler]]);
 }
-var pluginViewFacet = Facet.define({
-  converter: () => {
+var pluginViewFacet = defineFacet({
+  reduce: () => {
     let mountHandlers = [];
     let updateHandlers = [];
     let unmountHandlers = [];
-    const plugin = new ProseMirrorPlugin({
+    const plugin = new ProseMirrorPlugin2({
       key: pluginKey,
       view: (view) => {
         mountHandlers.forEach((fn) => fn(view));
@@ -1441,7 +1582,6 @@ var pluginViewFacet = Facet.define({
         };
       }
     });
-    const pluginFunc = () => [plugin];
     const register = (input) => {
       mountHandlers = [];
       updateHandlers = [];
@@ -1460,18 +1600,12 @@ var pluginViewFacet = Facet.define({
         }
       }
     };
-    return {
-      create: (input) => {
-        register(input);
-        return pluginFunc;
-      },
-      update: (input) => {
-        register(input);
-        return null;
-      }
+    return function reducer(input) {
+      register(input);
+      return plugin;
     };
   },
-  next: pluginFacet,
+  parent: pluginFacet,
   singleton: true
 });
 var pluginKey = new PluginKey("prosekit-plugin-view-handler");
@@ -1486,13 +1620,13 @@ function defineDocChangeHandler(handler) {
 }
 
 // src/extensions/events/dom-event.ts
-import { PluginKey as PluginKey2, ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm/state";
+import { PluginKey as PluginKey2, ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
 
 // src/utils/combine-event-handlers.ts
 function combineEventHandlers() {
   let _handlers = [];
   function setHandlers(handlers) {
-    _handlers = handlers;
+    _handlers = toReversed(handlers);
   }
   function combinedEventHandler(...args) {
     for (const handler of _handlers) {
@@ -1521,106 +1655,97 @@ function groupEntries(entries) {
 
 // src/extensions/events/dom-event.ts
 function defineDOMEventHandler(event, handler) {
-  return domEventFacet.extension([
+  return defineFacetPayload(domEventFacet, [
     [event, handler]
   ]);
 }
-var domEventFacet = Facet.define({
-  converter: () => {
+var domEventFacet = defineFacet({
+  reduce: () => {
     const setHandlersMap = {};
     const combinedHandlerMap = {};
+    let plugin = null;
     const update = (payloads) => {
+      var _a;
       let hasNewEvent = false;
       for (const [event] of payloads) {
         if (!setHandlersMap[event]) {
           hasNewEvent = true;
           const [setHandlers, combinedHandler] = combineEventHandlers();
           setHandlersMap[event] = setHandlers;
-          combinedHandlerMap[event] = combinedHandler;
+          const e = (view, eventObject) => {
+            return combinedHandler(view, eventObject);
+          };
+          combinedHandlerMap[event] = e;
         }
       }
       const map = groupEntries(payloads);
-      for (const [event, handlers] of Object.entries(map)) {
-        const setHandlers = setHandlersMap[event];
-        setHandlers(handlers != null ? handlers : []);
+      for (const [event, setHandlers] of Object.entries(setHandlersMap)) {
+        const handlers = (_a = map[event]) != null ? _a : [];
+        setHandlers(handlers);
       }
       if (hasNewEvent) {
-        return new ProseMirrorPlugin2({
+        plugin = new ProseMirrorPlugin3({
           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;
-      }
+    return function reducer(inputs) {
+      update(inputs);
+      return plugin != null ? plugin : [];
     };
   },
-  next: pluginFacet,
+  parent: pluginFacet,
   singleton: true
 });
 
 // src/extensions/events/editor-event.ts
-import { PluginKey as PluginKey3, ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
+import { PluginKey as PluginKey3, ProseMirrorPlugin as ProseMirrorPlugin4 } from "@prosekit/pm/state";
 function defineKeyDownHandler(handler) {
-  return editorEventFacet.extension([["keyDown", handler]]);
+  return defineFacetPayload(editorEventFacet, [["keyDown", handler]]);
 }
 function defineKeyPressHandler(handler) {
-  return editorEventFacet.extension([["keyPress", handler]]);
+  return defineFacetPayload(editorEventFacet, [["keyPress", handler]]);
 }
 function defineTextInputHandler(handler) {
-  return editorEventFacet.extension([["textInput", handler]]);
+  return defineFacetPayload(editorEventFacet, [["textInput", handler]]);
 }
 function defineClickOnHandler(handler) {
-  return editorEventFacet.extension([["clickOn", handler]]);
+  return defineFacetPayload(editorEventFacet, [["clickOn", handler]]);
 }
 function defineClickHandler(handler) {
-  return editorEventFacet.extension([["click", handler]]);
+  return defineFacetPayload(editorEventFacet, [["click", handler]]);
 }
 function defineDoubleClickOnHandler(handler) {
-  return editorEventFacet.extension([["doubleClickOn", handler]]);
+  return defineFacetPayload(editorEventFacet, [["doubleClickOn", handler]]);
 }
 function defineDoubleClickHandler(handler) {
-  return editorEventFacet.extension([["doubleClick", handler]]);
+  return defineFacetPayload(editorEventFacet, [["doubleClick", handler]]);
 }
 function defineTripleClickOnHandler(handler) {
-  return editorEventFacet.extension([["tripleClickOn", handler]]);
+  return defineFacetPayload(editorEventFacet, [["tripleClickOn", handler]]);
 }
 function defineTripleClickHandler(handler) {
-  return editorEventFacet.extension([["tripleClick", handler]]);
+  return defineFacetPayload(editorEventFacet, [["tripleClick", handler]]);
 }
 function definePasteHandler(handler) {
-  return editorEventFacet.extension([["paste", handler]]);
+  return defineFacetPayload(editorEventFacet, [["paste", handler]]);
 }
 function defineDropHandler(handler) {
-  return editorEventFacet.extension([["drop", handler]]);
+  return defineFacetPayload(editorEventFacet, [["drop", handler]]);
 }
 function defineScrollToSelectionHandler(handler) {
-  return editorEventFacet.extension([["scrollToSelection", handler]]);
+  return defineFacetPayload(editorEventFacet, [["scrollToSelection", handler]]);
 }
-var editorEventFacet = Facet.define({
-  converter: () => {
+var editorEventFacet = defineFacet({
+  reduce: () => {
     const [update, plugin] = setupEditorEventPlugin();
-    return {
-      create: (entries) => {
-        update(entries);
-        return () => plugin;
-      },
-      update: (entries) => {
-        update(entries);
-        return null;
-      }
+    return (entries) => {
+      update(entries);
+      return plugin;
     };
   },
-  next: pluginFacet,
+  parent: pluginFacet,
   singleton: true
 });
 function setupEditorEventPlugin() {
@@ -1652,8 +1777,8 @@ function setupEditorEventPlugin() {
     setDropHandlers((_k = map.drop) != null ? _k : []);
     setScrollToSelectionHandlers((_l = map.scrollToSelection) != null ? _l : []);
   };
-  const plugin = new ProseMirrorPlugin3({
-    key: new PluginKey3("prosekit-editor-handler"),
+  const plugin = new ProseMirrorPlugin4({
+    key: new PluginKey3("prosekit-editor-event"),
     props: {
       handleKeyDown,
       handleKeyPress,
@@ -1676,7 +1801,7 @@ function setupEditorEventPlugin() {
 function defineFocusChangeHandler(handler) {
   const handleFocus = () => handler(true);
   const handleBlur = () => handler(false);
-  return domEventFacet.extension([
+  return defineFacetPayload(domEventFacet, [
     ["focus", handleFocus],
     ["blur", handleBlur]
   ]);
@@ -1686,22 +1811,127 @@ function defineFocusChangeHandler(handler) {
 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;
+var isApple = typeof navigator !== "undefined" ? /Mac|iP(hone|[ao]d)/.test(navigator.platform) : false;
 
 // src/extensions/keymap.ts
-import { baseKeymap, chainCommands } from "@prosekit/pm/commands";
+import {
+  baseKeymap,
+  chainCommands,
+  createParagraphNear,
+  liftEmptyBlock,
+  newlineInCode
+} from "@prosekit/pm/commands";
 import { keydownHandler } from "@prosekit/pm/keymap";
 import { Plugin as Plugin3, PluginKey as PluginKey4 } from "@prosekit/pm/state";
+
+// src/commands/split-block-as.ts
+import {
+  AllSelection as AllSelection3,
+  NodeSelection as NodeSelection2,
+  TextSelection as TextSelection6
+} from "@prosekit/pm/state";
+import { canSplit } from "@prosekit/pm/transform";
+
+// 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/split-block-as.ts
+function splitBlockAs(splitNode) {
+  return (state, dispatch) => {
+    const { $from, $to } = state.selection;
+    if (state.selection instanceof NodeSelection2 && state.selection.node.isBlock) {
+      if (!$from.parentOffset || !canSplit(state.doc, $from.pos))
+        return false;
+      if (dispatch)
+        dispatch(state.tr.split($from.pos).scrollIntoView());
+      return true;
+    }
+    if (!$from.parent.isBlock)
+      return false;
+    if (dispatch) {
+      const atEnd = $to.parentOffset == $to.parent.content.size;
+      const tr = state.tr;
+      if (state.selection instanceof TextSelection6 || state.selection instanceof AllSelection3)
+        tr.deleteSelection();
+      const deflt = $from.depth == 0 ? null : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
+      const splitType = splitNode && splitNode($from.parent, deflt, atEnd);
+      let types = splitType ? [splitType] : atEnd && deflt ? [{ type: deflt }] : void 0;
+      let can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types);
+      if (!types && !can && canSplit(
+        tr.doc,
+        tr.mapping.map($from.pos),
+        1,
+        deflt ? [{ type: deflt }] : void 0
+      )) {
+        if (deflt)
+          types = [{ type: deflt }];
+        can = true;
+      }
+      if (can) {
+        tr.split(tr.mapping.map($from.pos), 1, types);
+        if (!atEnd && !$from.parentOffset && $from.parent.type != deflt) {
+          const first = tr.mapping.map($from.before()), $first = tr.doc.resolve(first);
+          if (deflt && $from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt))
+            tr.setNodeMarkup(tr.mapping.map($from.before()), deflt);
+        }
+      }
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+}
+
+// src/commands/split-block-enter.ts
+var splitBlockEnter = splitBlockAs((node, deflt, atEnd) => {
+  if (atEnd && deflt) {
+    const attrs = pickSplittableAttrs(node, deflt);
+    if (attrs) {
+      return { type: deflt, attrs };
+    }
+  }
+  return null;
+});
+function pickSplittableAttrs(node, type) {
+  var _a;
+  const attrs = {};
+  let found = false;
+  for (const [attr, value] of Object.entries(node.attrs)) {
+    const spec = (_a = type.spec.attrs) == null ? void 0 : _a[attr];
+    if (spec && spec.default !== value && spec.splittable === true) {
+      attrs[attr] = value;
+      found = true;
+    }
+  }
+  return found ? attrs : null;
+}
+
+// src/extensions/keymap.ts
+var customBaseKeymap = {
+  ...baseKeymap,
+  Enter: chainCommands(
+    newlineInCode,
+    createParagraphNear,
+    liftEmptyBlock,
+    splitBlockEnter
+  )
+};
 function defineKeymap(keymap) {
-  return keymapFacet.extension([keymap]);
+  return defineFacetPayload(keymapFacet, [keymap]);
 }
 function defineBaseKeymap(options) {
   var _a;
-  const priority = (_a = options == null ? void 0 : options.priority) != null ? _a : 3 /* low */;
-  return withPriority(defineKeymap(baseKeymap), priority);
+  const priority = (_a = options == null ? void 0 : options.priority) != null ? _a : 1 /* low */;
+  return withPriority(defineKeymap(customBaseKeymap), priority);
 }
-var keymapFacet = Facet.define({
-  converter: () => {
+var keymapFacet = defineFacet({
+  reduce: () => {
     let handler = null;
     const handlerWrapper = (view, event) => {
       if (handler)
@@ -1712,19 +1942,17 @@ var keymapFacet = Facet.define({
       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;
-      }
+    return (keymaps) => {
+      handler = keydownHandler(
+        mergeKeymaps(
+          // The keymap at the end have a higher priority.
+          toReversed(keymaps)
+        )
+      );
+      return plugin;
     };
   },
-  next: pluginFacet,
+  parent: pluginFacet,
   singleton: true
 });
 function mergeKeymaps(keymaps) {
@@ -1750,7 +1978,7 @@ function defineHistory() {
     "Mod-z": undo,
     "Shift-Mod-z": redo
   };
-  if (!isMac) {
+  if (!isApple) {
     keymap["Mod-y"] = redo;
   }
   return union([
@@ -1766,14 +1994,14 @@ function defineHistory() {
 // src/extensions/mark-spec.ts
 function defineMarkSpec(options) {
   const payload = [options, void 0];
-  return markSpecFacet.extension([payload]);
+  return defineFacetPayload(markSpecFacet, [payload]);
 }
 function defineMarkAttr(options) {
   const payload = [void 0, options];
-  return markSpecFacet.extension([payload]);
+  return defineFacetPayload(markSpecFacet, [payload]);
 }
-var markSpecFacet = Facet.define({
-  convert: (payloads) => {
+var markSpecFacet = defineFacet({
+  reducer: (payloads) => {
     const marks = {};
     const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
     const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
@@ -1850,37 +2078,42 @@ var markSpecFacet = Facet.define({
     }
     return { marks, nodes: {} };
   },
-  next: schemaFacet,
+  parent: schemaSpecFacet,
   singleton: true
 });
 
 // src/extensions/node-view.ts
-import { ProseMirrorPlugin as ProseMirrorPlugin4 } from "@prosekit/pm/state";
+import { PluginKey as PluginKey5, ProseMirrorPlugin as ProseMirrorPlugin5 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
 function defineNodeView(options) {
-  return nodeViewFacet.extension([options]);
+  return defineFacetPayload(nodeViewFacet, [options]);
 }
-var nodeViewFacet = Facet.define({
-  convert: (inputs) => {
+var nodeViewFacet = defineFacet({
+  reducer: (inputs) => {
     const nodeViews = {};
     for (const input of inputs) {
       if (!nodeViews[input.name]) {
         nodeViews[input.name] = input.constructor;
       }
     }
-    return () => [new ProseMirrorPlugin4({ props: { nodeViews } })];
+    return () => [
+      new ProseMirrorPlugin5({
+        key: new PluginKey5("prosekit-node-view"),
+        props: { nodeViews }
+      })
+    ];
   },
-  next: pluginFacet
+  parent: pluginFacet
 });
 
 // src/extensions/node-view-effect.ts
-import { ProseMirrorPlugin as ProseMirrorPlugin5 } from "@prosekit/pm/state";
+import { PluginKey as PluginKey6, ProseMirrorPlugin as ProseMirrorPlugin6 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
 function defineNodeViewFactory(options) {
-  return nodeViewFactoryFacet.extension([options]);
+  return defineFacetPayload(nodeViewFactoryFacet, [options]);
 }
-var nodeViewFactoryFacet = Facet.define({
-  convert: (inputs) => {
+var nodeViewFactoryFacet = defineFacet({
+  reducer: (inputs) => {
     const nodeViews = {};
     const options = {};
     const factories = {};
@@ -1902,9 +2135,14 @@ var nodeViewFactoryFacet = Facet.define({
         nodeViews[name] = factory(args);
       }
     }
-    return () => [new ProseMirrorPlugin5({ props: { nodeViews } })];
+    return () => [
+      new ProseMirrorPlugin6({
+        key: new PluginKey6("prosekit-node-view-effect"),
+        props: { nodeViews }
+      })
+    ];
   },
-  next: pluginFacet
+  parent: pluginFacet
 });
 
 // src/extensions/paragraph.ts
@@ -1920,7 +2158,7 @@ function defineParagraphSpec() {
   });
 }
 function defineParagraph() {
-  return withPriority(defineParagraphSpec(), 0 /* highest */);
+  return withPriority(defineParagraphSpec(), 4 /* highest */);
 }
 
 // src/extensions/text.ts
@@ -1931,20 +2169,30 @@ function defineText() {
   });
 }
 
+// src/utils/cache.ts
+function cache(fn) {
+  let result = void 0;
+  return () => {
+    if (result === void 0) {
+      result = fn();
+    }
+    return result;
+  };
+}
+
+// src/utils/can-use-regex-lookbehind.ts
+var canUseRegexLookbehind = cache(() => {
+  try {
+    return "ab".replace(new RegExp("(?<=a)b", "g"), "c") === "ac";
+  } catch (error) {
+    return false;
+  }
+});
+
 // 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 null;
-}
-
 // src/utils/get-id.ts
 var id = 0;
 function getId() {
@@ -1960,6 +2208,11 @@ function isInCodeBlock(selection) {
   return isCodeBlockType(selection.$from.parent.type) || isCodeBlockType(selection.$to.parent.type);
 }
 
+// src/utils/maybe-run.ts
+function maybeRun(value, ...args) {
+  return typeof value === "function" ? value(...args) : value;
+}
+
 // src/utils/unicode.ts
 var OBJECT_REPLACEMENT_CHARACTER = "\uFFFC";
 
@@ -1975,12 +2228,13 @@ function withSkipCodeBlock(command) {
 export {
   Editor,
   EditorNotFoundError,
-  Facet,
   OBJECT_REPLACEMENT_CHARACTER,
   Priority,
   ProseKitError,
   getId as _getId,
   addMark,
+  assert,
+  canUseRegexLookbehind,
   clsx,
   createEditor,
   defaultBlockAt,
@@ -1996,6 +2250,8 @@ export {
   defineDoubleClickHandler,
   defineDoubleClickOnHandler,
   defineDropHandler,
+  defineFacet,
+  defineFacetPayload,
   defineFocusChangeHandler,
   defineHistory,
   defineKeyDownHandler,
@@ -2027,8 +2283,11 @@ export {
   htmlFromNode,
   insertNode,
   isAllSelection,
+  isApple,
   isInCodeBlock,
   isMark,
+  isMarkAbsent,
+  isMarkActive,
   isNodeSelection,
   isProseMirrorNode,
   isTextSelection,
@@ -2036,6 +2295,7 @@ export {
   jsonFromNode,
   jsonFromState,
   keymapFacet,
+  maybeRun,
   nodeFromElement,
   nodeFromHTML,
   nodeFromJSON,