prosemirror-changeset 2.4.1 → 2.4.2

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.4.2 (2026-08-21)
+
+### Bug fixes
+
+Fix an issue where the diffing of changed ranges would waste a bunch of time building up tokens and trying to compute a diff even if the ranges were too big to find a solution for.
+
 ## 2.4.1 (2026-04-14)
 
 ### Bug fixes

package/dist/index.cjs

@@ -53,29 +53,30 @@ function tokens(frag, encoder, start, end, target) {
   }
   return target;
 }
-var MAX_DIFF_SIZE = 5000;
+var MAX_DIFF_SIZE = 2500;
 function minUnchanged(sizeA, sizeB) {
   return Math.min(15, Math.max(2, Math.floor(Math.max(sizeA, sizeB) / 10)));
 }
 function computeDiff(fragA, fragB, range) {
   var encoder = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : DefaultEncoder;
+  if (Math.max(range.toA - range.fromA, range.toB, range.fromB) > MAX_DIFF_SIZE) return [range];
   var tokA = tokens(fragA, encoder, range.fromA, range.toA, []);
   var tokB = tokens(fragB, encoder, range.fromB, range.toB, []);
+  return diff(tokA, tokB, range, encoder.compareTokens);
+}
+function diff(tokA, tokB, range, cmp) {
   var start = 0,
     endA = tokA.length,
     endB = tokB.length;
-  var cmp = encoder.compareTokens;
   while (start < tokA.length && start < tokB.length && cmp(tokA[start], tokB[start])) start++;
   if (start == tokA.length && start == tokB.length) return [];
   while (endA > start && endB > start && cmp(tokA[endA - 1], tokB[endB - 1])) endA--, endB--;
   if (endA == start || endB == start || endA == endB && endA == start + 1) return [range.slice(start, endA, start, endB)];
   var lenA = endA - start,
     lenB = endB - start;
-  var max = Math.min(MAX_DIFF_SIZE, lenA + lenB),
-    off = max + 1;
+  var max = Math.min(MAX_DIFF_SIZE, lenA + lenB);
   var history = [];
-  var frontier = [];
-  for (var len = off * 2, i = 0; i < len; i++) frontier[i] = -1;
+  var frontier = new Int16Array((max + 1) * 2).fill(-1);
   for (var size = 0; size <= max; size++) {
     var _loop = function _loop(_diag) {
         var next = frontier[_diag + 1 + max],
@@ -85,7 +86,7 @@ function computeDiff(fragA, fragB, range) {
         while (x < lenA && y < lenB && cmp(tokA[start + x], tokB[start + y])) x++, y++;
         frontier[_diag + max] = x;
         if (x >= lenA && y >= lenB) {
-          var diff = [],
+          var _diff = [],
             minSpan = minUnchanged(endA - start, endB - start);
           var fromA = -1,
             toA = -1,
@@ -96,14 +97,14 @@ function computeDiff(fragA, fragB, range) {
               fromA = fA;
               fromB = fB;
             } else {
-              if (fromA > -1) diff.push(range.slice(fromA, toA, fromB, toB));
+              if (fromA > -1) _diff.push(range.slice(fromA, toA, fromB, toB));
               fromA = fA;
               toA = tA;
               fromB = fB;
               toB = tB;
             }
           };
-          for (var _i = size - 1; _i >= 0; _i--) {
+          for (var i = size - 1; i >= 0; i--) {
             var _next = frontier[_diag + 1 + max],
               _prev = frontier[_diag - 1 + max];
             if (_next < _prev) {
@@ -117,11 +118,11 @@ function computeDiff(fragA, fragB, range) {
               y = x + _diag;
               add(x, x + 1, y, y);
             }
-            frontier = history[_i >> 1];
+            frontier = history[i >> 1];
           }
-          if (fromA > -1) diff.push(range.slice(fromA, toA, fromB, toB));
+          if (fromA > -1) _diff.push(range.slice(fromA, toA, fromB, toB));
           return {
-            v: diff.reverse()
+            v: _diff.reverse()
           };
         }
         diag = _diag;
@@ -133,7 +134,7 @@ function computeDiff(fragA, fragB, range) {
     }
     if (size % 2 == 0) history.push(frontier.slice());
   }
-  return [range.slice(start, endA, start, endB)];
+  return [range];
 }
 var Span = function () {
   function Span(length, data) {
@@ -431,32 +432,32 @@ var ChangeSet = function () {
       var newChanges = mergeAll(stepChanges, this.config.combine);
       var changes = Change.merge(this.changes, newChanges, this.config.combine);
       var updated = changes;
-      var _loop3 = function _loop3(_i3) {
-          var change = updated[_i3];
+      var _loop3 = function _loop3(_i2) {
+          var change = updated[_i2];
           if (change.fromA == change.toA || change.fromB == change.toB || !newChanges.some(function (r) {
             return r.toB > change.fromB && r.fromB < change.toB;
           })) {
-            _i2 = _i3;
+            _i = _i2;
             return 0;
           }
           var diff = computeDiff(_this.config.doc.content, newDoc.content, change, _this.config.encoder);
           if (diff.length == 1 && diff[0].fromB == 0 && diff[0].toB == change.toB - change.fromB) {
-            _i2 = _i3;
+            _i = _i2;
             return 0;
           }
           if (updated == changes) updated = changes.slice();
           if (diff.length == 1) {
-            updated[_i3] = diff[0];
+            updated[_i2] = diff[0];
           } else {
             var _updated;
-            (_updated = updated).splice.apply(_updated, [_i3, 1].concat(_toConsumableArray(diff)));
-            _i3 += diff.length - 1;
+            (_updated = updated).splice.apply(_updated, [_i2, 1].concat(_toConsumableArray(diff)));
+            _i2 += diff.length - 1;
           }
-          _i2 = _i3;
+          _i = _i2;
         },
         _ret2;
-      for (var _i2 = 0; _i2 < updated.length; _i2++) {
-        _ret2 = _loop3(_i2);
+      for (var _i = 0; _i < updated.length; _i++) {
+        _ret2 = _loop3(_i);
         if (_ret2 === 0) continue;
       }
       return new ChangeSet(this.config, updated);

package/dist/index.js

@@ -42,7 +42,7 @@ function tokens(frag, encoder, start, end, target) {
 // The code below will refuse to compute a diff with more than 5000
 // insertions or deletions, which takes about 300ms to reach on my
 // machine. This is a safeguard against runaway computations.
-const MAX_DIFF_SIZE = 5000;
+const MAX_DIFF_SIZE = 2500;
 // This obscure mess of constants computes the minimum length of an
 // unchanged range (not at the start/end of the compared content). The
 // idea is to make it higher in bigger replacements, so that you don't
@@ -52,11 +52,17 @@ function minUnchanged(sizeA, sizeB) {
     return Math.min(15, Math.max(2, Math.floor(Math.max(sizeA, sizeB) / 10)));
 }
 function computeDiff(fragA, fragB, range, encoder = DefaultEncoder) {
+    // When one side is longer than our max scan distance, the algorithm
+    // will never find a diff.
+    if (Math.max(range.toA - range.fromA, range.toB, range.fromB) > MAX_DIFF_SIZE)
+        return [range];
     let tokA = tokens(fragA, encoder, range.fromA, range.toA, []);
     let tokB = tokens(fragB, encoder, range.fromB, range.toB, []);
+    return diff(tokA, tokB, range, encoder.compareTokens);
+}
+function diff(tokA, tokB, range, cmp) {
     // Scan from both sides to cheaply eliminate work
     let start = 0, endA = tokA.length, endB = tokB.length;
-    let cmp = encoder.compareTokens;
     while (start < tokA.length && start < tokB.length && cmp(tokA[start], tokB[start]))
         start++;
     if (start == tokA.length && start == tokB.length)
@@ -71,11 +77,9 @@ function computeDiff(fragA, fragB, range, encoder = DefaultEncoder) {
     // See https://neil.fraser.name/writing/diff/myers.pdf and
     // https://blog.jcoglan.com/2017/02/12/the-myers-diff-algorithm-part-1/
     let lenA = endA - start, lenB = endB - start;
-    let max = Math.min(MAX_DIFF_SIZE, lenA + lenB), off = max + 1;
+    let max = Math.min(MAX_DIFF_SIZE, lenA + lenB);
     let history = [];
-    let frontier = [];
-    for (let len = off * 2, i = 0; i < len; i++)
-        frontier[i] = -1;
+    let frontier = new Int16Array((max + 1) * 2).fill(-1);
     for (let size = 0; size <= max; size++) {
         for (let diag = -size; diag <= size; diag += 2) {
             let next = frontier[diag + 1 + max], prev = frontier[diag - 1 + max];
@@ -132,7 +136,7 @@ function computeDiff(fragA, fragB, range, encoder = DefaultEncoder) {
     }
     // The loop exited, meaning the maximum amount of work was done.
     // Just return a change spanning the entire range.
-    return [range.slice(start, endA, start, endB)];
+    return [range];
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prosemirror-changeset",
-  "version": "2.4.1",
+  "version": "2.4.2",
   "description": "Distills a series of editing steps into deleted and added ranges",
   "type": "module",
   "main": "dist/index.cjs",

package/src/diff.ts

@@ -64,7 +64,7 @@ function tokens<T>(frag: Fragment, encoder: TokenEncoder<T>, start: number, end:
 // The code below will refuse to compute a diff with more than 5000
 // insertions or deletions, which takes about 300ms to reach on my
 // machine. This is a safeguard against runaway computations.
-const MAX_DIFF_SIZE = 5000
+const MAX_DIFF_SIZE = 2500
 
 // This obscure mess of constants computes the minimum length of an
 // unchanged range (not at the start/end of the compared content). The
@@ -76,12 +76,18 @@ function minUnchanged(sizeA: number, sizeB: number) {
 }
 
 export function computeDiff(fragA: Fragment, fragB: Fragment, range: Change, encoder: TokenEncoder<any> = DefaultEncoder) {
+  // When one side is longer than our max scan distance, the algorithm
+  // will never find a diff.
+  if (Math.max(range.toA - range.fromA, range.toB, range.fromB) > MAX_DIFF_SIZE)
+    return [range]
   let tokA = tokens(fragA, encoder, range.fromA, range.toA, [])
   let tokB = tokens(fragB, encoder, range.fromB, range.toB, [])
+  return diff(tokA, tokB, range, encoder.compareTokens)
+}
 
+function diff<T>(tokA: T[], tokB: T[], range: Change, cmp: (a: T, b: T) => boolean): Change[] {
   // Scan from both sides to cheaply eliminate work
   let start = 0, endA = tokA.length, endB = tokB.length
-  let cmp = encoder.compareTokens
   while (start < tokA.length && start < tokB.length && cmp(tokA[start], tokB[start])) start++
   if (start == tokA.length && start == tokB.length) return []
   while (endA > start && endB > start && cmp(tokA[endA - 1], tokB[endB - 1])) endA--, endB--
@@ -95,10 +101,9 @@ export function computeDiff(fragA: Fragment, fragB: Fragment, range: Change, enc
   // https://blog.jcoglan.com/2017/02/12/the-myers-diff-algorithm-part-1/
 
   let lenA = endA - start, lenB = endB - start
-  let max = Math.min(MAX_DIFF_SIZE, lenA + lenB), off = max + 1
-  let history: number[][] = []
-  let frontier: number[] = []
-  for (let len = off * 2, i = 0; i < len; i++) frontier[i] = -1
+  let max = Math.min(MAX_DIFF_SIZE, lenA + lenB)
+  let history: Int16Array[] = []
+  let frontier = new Int16Array((max + 1) * 2).fill(-1)
 
   for (let size = 0; size <= max; size++) {
     for (let diag = -size; diag <= size; diag += 2) {
@@ -109,7 +114,7 @@ export function computeDiff(fragA: Fragment, fragB: Fragment, range: Change, enc
       // Found a match
       if (x >= lenA && y >= lenB) {
         // Trace back through the history to build up a set of changed ranges.
-        let diff = [], minSpan = minUnchanged(endA - start, endB - start)
+        let diff: Change[] = [], minSpan = minUnchanged(endA - start, endB - start)
         // Used to add steps to a diff one at a time, back to front, merging
         // ones that are less than minSpan tokens apart
         let fromA = -1, toA = -1, fromB = -1, toB = -1
@@ -147,5 +152,5 @@ export function computeDiff(fragA: Fragment, fragB: Fragment, range: Change, enc
   }
   // The loop exited, meaning the maximum amount of work was done.
   // Just return a change spanning the entire range.
-  return [range.slice(start, endA, start, endB)]
+  return [range]
 }