prosemirror-transform 1.12.2 → 1.12.3

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 1.12.3 (2026-10-22)
+
+### Bug fixes
+
+Fix an issue that could make inverting a mapped `AddMarkStep` or `RemoveMarkStep` sometimes produce an inverse that didn't actually cancel out with the step itself.
+
 ## 1.12.2 (2026-09-25)
 
 ### Bug fixes

package/dist/index.cjs

@@ -3,6 +3,9 @@
 function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
 function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
 function _isNativeFunction(fn) { try { return Function.toString.call(fn).indexOf("[native code]") !== -1; } catch (e) { return typeof fn === "function"; } }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
@@ -363,6 +366,7 @@ var AddMarkStep = function (_Step) {
     key: "apply",
     value: function apply(doc) {
       var _this2 = this;
+      if (this.from == this.to) return new StepResult(doc, null);
       var oldSlice = doc.slice(this.from, this.to),
         $from = doc.resolve(this.from);
       var parent = $from.node($from.sharedDepth(this.to));
@@ -374,16 +378,40 @@ var AddMarkStep = function (_Step) {
     }
   }, {
     key: "invert",
-    value: function invert() {
-      return new RemoveMarkStep(this.from, this.to, this.mark);
+    value: function invert(doc) {
+      var _this3 = this;
+      var steps = [];
+      doc.nodesBetween(this.from, this.to, function (node, pos) {
+        if (node.isInline && node.isAtom) {
+          var added = _this3.mark.addToSet(node.marks);
+          if (!prosemirrorModel.Mark.sameSet(added, node.marks)) {
+            var from = Math.max(_this3.from, pos),
+              to = Math.min(_this3.to, pos + node.nodeSize);
+            steps.push(new RemoveMarkStep(from, to, _this3.mark));
+            var _iterator = _createForOfIteratorHelper(node.marks),
+              _step;
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                var mark = _step.value;
+                if (!mark.isInSet(added)) steps.push(new AddMarkStep(from, to, mark));
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+          }
+        }
+      });
+      return steps.length == 0 ? new RemoveMarkStep(this.from, this.from, this.mark) : steps.length == 1 ? steps[0] : new MarkSetStep(steps);
     }
   }, {
     key: "map",
     value: function map(mapping) {
-      var from = mapping.mapResult(this.from, 1),
-        to = mapping.mapResult(this.to, -1);
-      if (from.deleted && to.deleted || from.pos >= to.pos) return null;
-      return new AddMarkStep(from.pos, to.pos, this.mark);
+      var from = mapping.map(this.from, 1),
+        to = mapping.map(this.to, -1);
+      if (from >= to) return null;
+      return new AddMarkStep(from, to, this.mark);
     }
   }, {
     key: "merge",
@@ -415,36 +443,42 @@ var RemoveMarkStep = function (_Step2) {
   _inherits(RemoveMarkStep, _Step2);
   var _super2 = _createSuper(RemoveMarkStep);
   function RemoveMarkStep(from, to, mark) {
-    var _this3;
+    var _this4;
     _classCallCheck(this, RemoveMarkStep);
-    _this3 = _super2.call(this);
-    _this3.from = from;
-    _this3.to = to;
-    _this3.mark = mark;
-    return _this3;
+    _this4 = _super2.call(this);
+    _this4.from = from;
+    _this4.to = to;
+    _this4.mark = mark;
+    return _this4;
   }
   _createClass(RemoveMarkStep, [{
     key: "apply",
     value: function apply(doc) {
-      var _this4 = this;
+      var _this5 = this;
+      if (this.from == this.to) return new StepResult(doc, null);
       var oldSlice = doc.slice(this.from, this.to);
       var slice = new prosemirrorModel.Slice(mapFragment(oldSlice.content, function (node) {
-        return node.mark(_this4.mark.removeFromSet(node.marks));
+        return node.mark(_this5.mark.removeFromSet(node.marks));
       }, doc), oldSlice.openStart, oldSlice.openEnd);
       return StepResult.fromReplace(doc, this.from, this.to, slice);
     }
   }, {
     key: "invert",
-    value: function invert() {
-      return new AddMarkStep(this.from, this.to, this.mark);
+    value: function invert(doc) {
+      var _this6 = this;
+      var steps = [];
+      doc.nodesBetween(this.from, this.to, function (node, pos) {
+        if (node.isInline && node.isAtom && _this6.mark.isInSet(node.marks)) steps.push(new AddMarkStep(Math.max(_this6.from, pos), Math.min(_this6.to, pos + node.nodeSize), _this6.mark));
+      });
+      return steps.length == 0 ? new AddMarkStep(this.from, this.from, this.mark) : steps.length == 1 ? steps[0] : new MarkSetStep(steps);
     }
   }, {
     key: "map",
     value: function map(mapping) {
-      var from = mapping.mapResult(this.from, 1),
-        to = mapping.mapResult(this.to, -1);
-      if (from.deleted && to.deleted || from.pos >= to.pos) return null;
-      return new RemoveMarkStep(from.pos, to.pos, this.mark);
+      var from = mapping.map(this.from, 1),
+        to = mapping.map(this.to, -1);
+      if (from >= to) return null;
+      return new RemoveMarkStep(from, to, this.mark);
     }
   }, {
     key: "merge",
@@ -472,16 +506,95 @@ var RemoveMarkStep = function (_Step2) {
   return RemoveMarkStep;
 }(Step);
 Step.jsonID("removeMark", RemoveMarkStep);
-var AddNodeMarkStep = function (_Step3) {
-  _inherits(AddNodeMarkStep, _Step3);
-  var _super3 = _createSuper(AddNodeMarkStep);
+var MarkSetStep = function (_Step3) {
+  _inherits(MarkSetStep, _Step3);
+  var _super3 = _createSuper(MarkSetStep);
+  function MarkSetStep(steps) {
+    var _this7;
+    _classCallCheck(this, MarkSetStep);
+    _this7 = _super3.call(this);
+    _this7.steps = steps;
+    return _this7;
+  }
+  _createClass(MarkSetStep, [{
+    key: "apply",
+    value: function apply(doc) {
+      var _iterator2 = _createForOfIteratorHelper(this.steps),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var step = _step2.value;
+          var result = step.apply(doc);
+          if (!result.doc) return result;
+          doc = result.doc;
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return new StepResult(doc, null);
+    }
+  }, {
+    key: "invert",
+    value: function invert(doc) {
+      return new MarkSetStep(this.steps.map(function (s) {
+        return s.invert(doc);
+      }));
+    }
+  }, {
+    key: "map",
+    value: function map(mapping) {
+      var result = [];
+      var _iterator3 = _createForOfIteratorHelper(this.steps),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var step = _step3.value;
+          var mapped = step.map(mapping);
+          if (mapped) result.push(mapped);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return result.length ? new MarkSetStep(result) : null;
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        stepType: "markSet",
+        steps: this.steps.map(function (s) {
+          return s.toJSON();
+        })
+      };
+    }
+  }, {
+    key: "fromJSON",
+    value: function fromJSON(schema, json) {
+      if (!Array.isArray(json.steps) || !json.steps.every(function (s) {
+        return s.stepType == "addMark" || s.stepType == "removeMark";
+      })) throw new RangeError("Invalid JSON for MarkSetStep");
+      return new MarkSetStep(json.steps.map(function (s) {
+        return Step.fromJSON(schema, s);
+      }));
+    }
+  }]);
+  return MarkSetStep;
+}(Step);
+Step.jsonID("markSet", MarkSetStep);
+var AddNodeMarkStep = function (_Step4) {
+  _inherits(AddNodeMarkStep, _Step4);
+  var _super4 = _createSuper(AddNodeMarkStep);
   function AddNodeMarkStep(pos, mark) {
-    var _this5;
+    var _this8;
     _classCallCheck(this, AddNodeMarkStep);
-    _this5 = _super3.call(this);
-    _this5.pos = pos;
-    _this5.mark = mark;
-    return _this5;
+    _this8 = _super4.call(this);
+    _this8.pos = pos;
+    _this8.mark = mark;
+    return _this8;
   }
   _createClass(AddNodeMarkStep, [{
     key: "apply",
@@ -529,16 +642,16 @@ var AddNodeMarkStep = function (_Step3) {
   return AddNodeMarkStep;
 }(Step);
 Step.jsonID("addNodeMark", AddNodeMarkStep);
-var RemoveNodeMarkStep = function (_Step4) {
-  _inherits(RemoveNodeMarkStep, _Step4);
-  var _super4 = _createSuper(RemoveNodeMarkStep);
+var RemoveNodeMarkStep = function (_Step5) {
+  _inherits(RemoveNodeMarkStep, _Step5);
+  var _super5 = _createSuper(RemoveNodeMarkStep);
   function RemoveNodeMarkStep(pos, mark) {
-    var _this6;
+    var _this9;
     _classCallCheck(this, RemoveNodeMarkStep);
-    _this6 = _super4.call(this);
-    _this6.pos = pos;
-    _this6.mark = mark;
-    return _this6;
+    _this9 = _super5.call(this);
+    _this9.pos = pos;
+    _this9.mark = mark;
+    return _this9;
   }
   _createClass(RemoveNodeMarkStep, [{
     key: "apply",
@@ -580,19 +693,19 @@ var RemoveNodeMarkStep = function (_Step4) {
   return RemoveNodeMarkStep;
 }(Step);
 Step.jsonID("removeNodeMark", RemoveNodeMarkStep);
-var ReplaceStep = function (_Step5) {
-  _inherits(ReplaceStep, _Step5);
-  var _super5 = _createSuper(ReplaceStep);
+var ReplaceStep = function (_Step6) {
+  _inherits(ReplaceStep, _Step6);
+  var _super6 = _createSuper(ReplaceStep);
   function ReplaceStep(from, to, slice) {
-    var _this7;
+    var _this10;
     var structure = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
     _classCallCheck(this, ReplaceStep);
-    _this7 = _super5.call(this);
-    _this7.from = from;
-    _this7.to = to;
-    _this7.slice = slice;
-    _this7.structure = structure;
-    return _this7;
+    _this10 = _super6.call(this);
+    _this10.from = from;
+    _this10.to = to;
+    _this10.slice = slice;
+    _this10.structure = structure;
+    return _this10;
   }
   _createClass(ReplaceStep, [{
     key: "apply",
@@ -655,22 +768,22 @@ var ReplaceStep = function (_Step5) {
 }(Step);
 ReplaceStep.MAP_BIAS = 1;
 Step.jsonID("replace", ReplaceStep);
-var ReplaceAroundStep = function (_Step6) {
-  _inherits(ReplaceAroundStep, _Step6);
-  var _super6 = _createSuper(ReplaceAroundStep);
+var ReplaceAroundStep = function (_Step7) {
+  _inherits(ReplaceAroundStep, _Step7);
+  var _super7 = _createSuper(ReplaceAroundStep);
   function ReplaceAroundStep(from, to, gapFrom, gapTo, slice, insert) {
-    var _this8;
+    var _this11;
     var structure = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
     _classCallCheck(this, ReplaceAroundStep);
-    _this8 = _super6.call(this);
-    _this8.from = from;
-    _this8.to = to;
-    _this8.gapFrom = gapFrom;
-    _this8.gapTo = gapTo;
-    _this8.slice = slice;
-    _this8.insert = insert;
-    _this8.structure = structure;
-    return _this8;
+    _this11 = _super7.call(this);
+    _this11.from = from;
+    _this11.to = to;
+    _this11.gapFrom = gapFrom;
+    _this11.gapTo = gapTo;
+    _this11.slice = slice;
+    _this11.insert = insert;
+    _this11.structure = structure;
+    return _this11;
   }
   _createClass(ReplaceAroundStep, [{
     key: "apply",
@@ -747,27 +860,17 @@ function contentBetween(doc, from, to) {
   return false;
 }
 function _addMark(tr, from, to, mark) {
-  var removed = [],
-    added = [];
-  var removing, adding;
+  var added = [],
+    adding;
   tr.doc.nodesBetween(from, to, function (node, pos, parent) {
     if (!node.isInline) return;
     var marks = node.marks;
     if (!mark.isInSet(marks) && parent.type.allowsMarkType(mark.type)) {
       var start = Math.max(pos, from),
         end = Math.min(pos + node.nodeSize, to);
-      var newSet = mark.addToSet(marks);
-      for (var i = 0; i < marks.length; i++) {
-        if (!marks[i].isInSet(newSet)) {
-          if (removing && removing.to == start && removing.mark.eq(marks[i])) removing.to = end;else removed.push(removing = new RemoveMarkStep(start, end, marks[i]));
-        }
-      }
       if (adding && adding.to == start) adding.to = end;else added.push(adding = new AddMarkStep(start, end, mark));
     }
   });
-  removed.forEach(function (s) {
-    return tr.step(s);
-  });
   added.forEach(function (s) {
     return tr.step(s);
   });
@@ -776,7 +879,7 @@ function _removeMark(tr, from, to, mark) {
   var matched = [],
     step = 0;
   tr.doc.nodesBetween(from, to, function (node, pos) {
-    if (!node.isInline) return;
+    if (!node.isInline || !node.isAtom) return;
     step++;
     var toRemove = null;
     if (mark instanceof prosemirrorModel.MarkType) {
@@ -1552,17 +1655,17 @@ function coveredDepths($from, $to) {
   }
   return result;
 }
-var AttrStep = function (_Step7) {
-  _inherits(AttrStep, _Step7);
-  var _super7 = _createSuper(AttrStep);
+var AttrStep = function (_Step8) {
+  _inherits(AttrStep, _Step8);
+  var _super8 = _createSuper(AttrStep);
   function AttrStep(pos, attr, value) {
-    var _this9;
+    var _this12;
     _classCallCheck(this, AttrStep);
-    _this9 = _super7.call(this);
-    _this9.pos = pos;
-    _this9.attr = attr;
-    _this9.value = value;
-    return _this9;
+    _this12 = _super8.call(this);
+    _this12.pos = pos;
+    _this12.attr = attr;
+    _this12.value = value;
+    return _this12;
   }
   _createClass(AttrStep, [{
     key: "apply",
@@ -1611,16 +1714,16 @@ var AttrStep = function (_Step7) {
   return AttrStep;
 }(Step);
 Step.jsonID("attr", AttrStep);
-var DocAttrStep = function (_Step8) {
-  _inherits(DocAttrStep, _Step8);
-  var _super8 = _createSuper(DocAttrStep);
+var DocAttrStep = function (_Step9) {
+  _inherits(DocAttrStep, _Step9);
+  var _super9 = _createSuper(DocAttrStep);
   function DocAttrStep(attr, value) {
-    var _this10;
+    var _this13;
     _classCallCheck(this, DocAttrStep);
-    _this10 = _super8.call(this);
-    _this10.attr = attr;
-    _this10.value = value;
-    return _this10;
+    _this13 = _super9.call(this);
+    _this13.attr = attr;
+    _this13.value = value;
+    return _this13;
   }
   _createClass(DocAttrStep, [{
     key: "apply",
@@ -1667,10 +1770,10 @@ var DocAttrStep = function (_Step8) {
 Step.jsonID("docAttr", DocAttrStep);
 exports.TransformError = function (_Error) {
   _inherits(TransformError, _Error);
-  var _super9 = _createSuper(TransformError);
+  var _super10 = _createSuper(TransformError);
   function TransformError() {
     _classCallCheck(this, TransformError);
-    return _super9.apply(this, arguments);
+    return _super10.apply(this, arguments);
   }
   return _createClass(TransformError);
 }(_wrapNativeSuper(Error));
@@ -1697,8 +1800,8 @@ var Transform = function () {
     }
   }, {
     key: "step",
-    value: function step(_step) {
-      var result = this.maybeStep(_step);
+    value: function step(_step4) {
+      var result = this.maybeStep(_step4);
       if (result.failed) throw new exports.TransformError(result.failed);
       return this;
     }

package/dist/index.d.cts

@@ -554,7 +554,7 @@ declare class AddMarkStep extends Step {
     */
     mark: Mark);
     apply(doc: Node): StepResult;
-    invert(): Step;
+    invert(doc: Node): Step;
     map(mapping: Mappable): Step | null;
     merge(other: Step): Step | null;
     toJSON(): any;
@@ -592,7 +592,7 @@ declare class RemoveMarkStep extends Step {
     */
     mark: Mark);
     apply(doc: Node): StepResult;
-    invert(): Step;
+    invert(doc: Node): Step;
     map(mapping: Mappable): Step | null;
     merge(other: Step): Step | null;
     toJSON(): any;

package/dist/index.d.ts

@@ -554,7 +554,7 @@ declare class AddMarkStep extends Step {
     */
     mark: Mark);
     apply(doc: Node): StepResult;
-    invert(): Step;
+    invert(doc: Node): Step;
     map(mapping: Mappable): Step | null;
     merge(other: Step): Step | null;
     toJSON(): any;
@@ -592,7 +592,7 @@ declare class RemoveMarkStep extends Step {
     */
     mark: Mark);
     apply(doc: Node): StepResult;
-    invert(): Step;
+    invert(doc: Node): Step;
     map(mapping: Mappable): Step | null;
     merge(other: Step): Step | null;
     toJSON(): any;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { ReplaceError, Slice, Fragment, MarkType, Mark } from 'prosemirror-model';
+import { ReplaceError, Slice, Mark, Fragment, MarkType } from 'prosemirror-model';
 
 // Recovery values encode a range index and an offset. They are
 // represented as numbers, because tons of them will be created when
@@ -457,6 +457,8 @@ class AddMarkStep extends Step {
         this.mark = mark;
     }
     apply(doc) {
+        if (this.from == this.to)
+            return new StepResult(doc, null);
         let oldSlice = doc.slice(this.from, this.to), $from = doc.resolve(this.from);
         let parent = $from.node($from.sharedDepth(this.to));
         let slice = new Slice(mapFragment(oldSlice.content, (node, parent) => {
@@ -466,14 +468,28 @@ class AddMarkStep extends Step {
         }, parent), oldSlice.openStart, oldSlice.openEnd);
         return StepResult.fromReplace(doc, this.from, this.to, slice);
     }
-    invert() {
-        return new RemoveMarkStep(this.from, this.to, this.mark);
+    invert(doc) {
+        let steps = [];
+        doc.nodesBetween(this.from, this.to, (node, pos) => {
+            if (node.isInline && node.isAtom) {
+                let added = this.mark.addToSet(node.marks);
+                if (!Mark.sameSet(added, node.marks)) {
+                    let from = Math.max(this.from, pos), to = Math.min(this.to, pos + node.nodeSize);
+                    steps.push(new RemoveMarkStep(from, to, this.mark));
+                    for (let mark of node.marks)
+                        if (!mark.isInSet(added))
+                            steps.push(new AddMarkStep(from, to, mark));
+                }
+            }
+        });
+        return steps.length == 0 ? new RemoveMarkStep(this.from, this.from, this.mark)
+            : steps.length == 1 ? steps[0] : new MarkSetStep(steps);
     }
     map(mapping) {
-        let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-        if (from.deleted && to.deleted || from.pos >= to.pos)
+        let from = mapping.map(this.from, 1), to = mapping.map(this.to, -1);
+        if (from >= to)
             return null;
-        return new AddMarkStep(from.pos, to.pos, this.mark);
+        return new AddMarkStep(from, to, this.mark);
     }
     merge(other) {
         if (other instanceof AddMarkStep &&
@@ -522,20 +538,28 @@ class RemoveMarkStep extends Step {
         this.mark = mark;
     }
     apply(doc) {
+        if (this.from == this.to)
+            return new StepResult(doc, null);
         let oldSlice = doc.slice(this.from, this.to);
         let slice = new Slice(mapFragment(oldSlice.content, node => {
             return node.mark(this.mark.removeFromSet(node.marks));
         }, doc), oldSlice.openStart, oldSlice.openEnd);
         return StepResult.fromReplace(doc, this.from, this.to, slice);
     }
-    invert() {
-        return new AddMarkStep(this.from, this.to, this.mark);
+    invert(doc) {
+        let steps = [];
+        doc.nodesBetween(this.from, this.to, (node, pos) => {
+            if (node.isInline && node.isAtom && this.mark.isInSet(node.marks))
+                steps.push(new AddMarkStep(Math.max(this.from, pos), Math.min(this.to, pos + node.nodeSize), this.mark));
+        });
+        return steps.length == 0 ? new AddMarkStep(this.from, this.from, this.mark)
+            : steps.length == 1 ? steps[0] : new MarkSetStep(steps);
     }
     map(mapping) {
-        let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-        if (from.deleted && to.deleted || from.pos >= to.pos)
+        let from = mapping.map(this.from, 1), to = mapping.map(this.to, -1);
+        if (from >= to)
             return null;
-        return new RemoveMarkStep(from.pos, to.pos, this.mark);
+        return new RemoveMarkStep(from, to, this.mark);
     }
     merge(other) {
         if (other instanceof RemoveMarkStep &&
@@ -558,6 +582,42 @@ class RemoveMarkStep extends Step {
     }
 }
 Step.jsonID("removeMark", RemoveMarkStep);
+class MarkSetStep extends Step {
+    constructor(steps) {
+        super();
+        this.steps = steps;
+    }
+    apply(doc) {
+        for (let step of this.steps) {
+            let result = step.apply(doc);
+            if (!result.doc)
+                return result;
+            doc = result.doc;
+        }
+        return new StepResult(doc, null);
+    }
+    invert(doc) {
+        return new MarkSetStep(this.steps.map(s => s.invert(doc)));
+    }
+    map(mapping) {
+        let result = [];
+        for (let step of this.steps) {
+            let mapped = step.map(mapping);
+            if (mapped)
+                result.push(mapped);
+        }
+        return result.length ? new MarkSetStep(result) : null;
+    }
+    toJSON() {
+        return { stepType: "markSet", steps: this.steps.map(s => s.toJSON()) };
+    }
+    fromJSON(schema, json) {
+        if (!Array.isArray(json.steps) || !json.steps.every((s) => s.stepType == "addMark" || s.stepType == "removeMark"))
+            throw new RangeError("Invalid JSON for MarkSetStep");
+        return new MarkSetStep(json.steps.map((s) => Step.fromJSON(schema, s)));
+    }
+}
+Step.jsonID("markSet", MarkSetStep);
 /**
 Add a mark to a specific node.
 */
@@ -882,36 +942,25 @@ function contentBetween(doc, from, to) {
 }
 
 function addMark(tr, from, to, mark) {
-    let removed = [], added = [];
-    let removing, adding;
+    let added = [], adding;
     tr.doc.nodesBetween(from, to, (node, pos, parent) => {
         if (!node.isInline)
             return;
         let marks = node.marks;
         if (!mark.isInSet(marks) && parent.type.allowsMarkType(mark.type)) {
             let start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to);
-            let newSet = mark.addToSet(marks);
-            for (let i = 0; i < marks.length; i++) {
-                if (!marks[i].isInSet(newSet)) {
-                    if (removing && removing.to == start && removing.mark.eq(marks[i]))
-                        removing.to = end;
-                    else
-                        removed.push(removing = new RemoveMarkStep(start, end, marks[i]));
-                }
-            }
             if (adding && adding.to == start)
                 adding.to = end;
             else
                 added.push(adding = new AddMarkStep(start, end, mark));
         }
     });
-    removed.forEach(s => tr.step(s));
     added.forEach(s => tr.step(s));
 }
 function removeMark(tr, from, to, mark) {
     let matched = [], step = 0;
     tr.doc.nodesBetween(from, to, (node, pos) => {
-        if (!node.isInline)
+        if (!node.isInline || !node.isAtom)
             return;
         step++;
         let toRemove = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prosemirror-transform",
-  "version": "1.12.2",
+  "version": "1.12.3",
   "description": "ProseMirror document transformations",
   "type": "module",
   "main": "dist/index.cjs",

package/src/mark.ts

@@ -6,39 +6,23 @@ import {AddMarkStep, RemoveMarkStep} from "./mark_step"
 import {ReplaceStep} from "./replace_step"
 
 export function addMark(tr: Transform, from: number, to: number, mark: Mark) {
-  let removed: Step[] = [], added: Step[] = []
-  let removing: RemoveMarkStep | undefined, adding: AddMarkStep | undefined
+  let added: Step[] = [], adding: AddMarkStep | undefined
   tr.doc.nodesBetween(from, to, (node, pos, parent) => {
     if (!node.isInline) return
     let marks = node.marks
     if (!mark.isInSet(marks) && parent!.type.allowsMarkType(mark.type)) {
       let start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to)
-      let newSet = mark.addToSet(marks)
-
-      for (let i = 0; i < marks.length; i++) {
-        if (!marks[i].isInSet(newSet)) {
-          if (removing && removing.to == start && removing.mark.eq(marks[i]))
-            (removing as any).to = end
-          else
-            removed.push(removing = new RemoveMarkStep(start, end, marks[i]))
-        }
-      }
-
-      if (adding && adding.to == start)
-        (adding as any).to = end
-      else
-        added.push(adding = new AddMarkStep(start, end, mark))
+      if (adding && adding.to == start) (adding as any).to = end
+      else added.push(adding = new AddMarkStep(start, end, mark))
     }
   })
-
-  removed.forEach(s => tr.step(s))
   added.forEach(s => tr.step(s))
 }
 
 export function removeMark(tr: Transform, from: number, to: number, mark?: Mark | MarkType | null) {
   let matched: {style: Mark, from: number, to: number, step: number}[] = [], step = 0
   tr.doc.nodesBetween(from, to, (node, pos) => {
-    if (!node.isInline) return
+    if (!node.isInline || !node.isAtom) return
     step++
     let toRemove = null
     if (mark instanceof MarkType) {

package/src/mark_step.ts

@@ -28,6 +28,7 @@ export class AddMarkStep extends Step {
   }
 
   apply(doc: Node) {
+    if (this.from == this.to) return new StepResult(doc, null)
     let oldSlice = doc.slice(this.from, this.to), $from = doc.resolve(this.from)
     let parent = $from.node($from.sharedDepth(this.to))
     let slice = new Slice(mapFragment(oldSlice.content, (node, parent) => {
@@ -37,14 +38,27 @@ export class AddMarkStep extends Step {
     return StepResult.fromReplace(doc, this.from, this.to, slice)
   }
 
-  invert(): Step {
-    return new RemoveMarkStep(this.from, this.to, this.mark)
+  invert(doc: Node): Step {
+    let steps: (RemoveMarkStep | AddMarkStep)[] = []
+    doc.nodesBetween(this.from, this.to, (node, pos) => {
+      if (node.isInline && node.isAtom) {
+        let added = this.mark.addToSet(node.marks)
+        if (!Mark.sameSet(added, node.marks)) {
+          let from = Math.max(this.from, pos), to = Math.min(this.to, pos + node.nodeSize)
+          steps.push(new RemoveMarkStep(from, to, this.mark))
+          for (let mark of node.marks) if (!mark.isInSet(added))
+            steps.push(new AddMarkStep(from, to, mark))
+        }
+      }
+    })
+    return steps.length == 0 ? new RemoveMarkStep(this.from, this.from, this.mark)
+      : steps.length == 1 ? steps[0] : new MarkSetStep(steps)
   }
 
   map(mapping: Mappable): Step | null {
-    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1)
-    if (from.deleted && to.deleted || from.pos >= to.pos) return null
-    return new AddMarkStep(from.pos, to.pos, this.mark)
+    let from = mapping.map(this.from, 1), to = mapping.map(this.to, -1)
+    if (from >= to) return null
+    return new AddMarkStep(from, to, this.mark)
   }
 
   merge(other: Step): Step | null {
@@ -86,6 +100,7 @@ export class RemoveMarkStep extends Step {
   }
 
   apply(doc: Node) {
+    if (this.from == this.to) return new StepResult(doc, null)
     let oldSlice = doc.slice(this.from, this.to)
     let slice = new Slice(mapFragment(oldSlice.content, node => {
       return node.mark(this.mark.removeFromSet(node.marks))
@@ -93,14 +108,20 @@ export class RemoveMarkStep extends Step {
     return StepResult.fromReplace(doc, this.from, this.to, slice)
   }
 
-  invert(): Step {
-    return new AddMarkStep(this.from, this.to, this.mark)
+  invert(doc: Node): Step {
+    let steps: AddMarkStep[] = []
+    doc.nodesBetween(this.from, this.to, (node, pos) => {
+      if (node.isInline && node.isAtom && this.mark.isInSet(node.marks))
+        steps.push(new AddMarkStep(Math.max(this.from, pos), Math.min(this.to, pos + node.nodeSize), this.mark))
+    })
+    return steps.length == 0 ? new AddMarkStep(this.from, this.from, this.mark)
+      : steps.length == 1 ? steps[0] : new MarkSetStep(steps)
   }
 
   map(mapping: Mappable): Step | null {
-    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1)
-    if (from.deleted && to.deleted || from.pos >= to.pos) return null
-    return new RemoveMarkStep(from.pos, to.pos, this.mark)
+    let from = mapping.map(this.from, 1), to = mapping.map(this.to, -1)
+    if (from >= to) return null
+    return new RemoveMarkStep(from, to, this.mark)
   }
 
   merge(other: Step): Step | null {
@@ -127,6 +148,48 @@ export class RemoveMarkStep extends Step {
 
 Step.jsonID("removeMark", RemoveMarkStep)
 
+class MarkSetStep extends Step {
+  constructor(
+    readonly steps: readonly (AddMarkStep | RemoveMarkStep)[]
+  ) {
+    super()
+  }
+
+  apply(doc: Node) {
+    for (let step of this.steps) {
+      let result = step.apply(doc)
+      if (!result.doc) return result
+      doc = result.doc
+    }
+    return new StepResult(doc, null)
+  }
+
+  invert(doc: Node): Step {
+    return new MarkSetStep(this.steps.map(s => s.invert(doc) as AddMarkStep | RemoveMarkStep))
+  }
+
+  map(mapping: Mappable) {
+    let result: (AddMarkStep | RemoveMarkStep)[] = []
+    for (let step of this.steps) {
+      let mapped = step.map(mapping)
+      if (mapped) result.push(mapped as AddMarkStep | RemoveMarkStep)
+    }
+    return result.length ? new MarkSetStep(result) : null
+  }
+
+  toJSON() {
+    return {stepType: "markSet", steps: this.steps.map(s => s.toJSON())}
+  }
+
+  fromJSON(schema: Schema, json: any) {
+    if (!Array.isArray(json.steps) || !json.steps.every((s: any) => s.stepType == "addMark" || s.stepType == "removeMark"))
+      throw new RangeError("Invalid JSON for MarkSetStep")
+    return new MarkSetStep(json.steps.map((s: any) => Step.fromJSON(schema, s)))
+  }
+}
+
+Step.jsonID("markSet", MarkSetStep)
+
 /// Add a mark to a specific node.
 export class AddNodeMarkStep extends Step {
   /// Create a node mark step.