prosemirror-changeset 2.4.3 → 2.4.4

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.4.4 (2026-09-25)
+
+### Bug fixes
+
+Increase the size of changed chunks that diffing will compare prefix and suffix equality for, even if too big to properly diff.
+
 ## 2.4.3 (2026-09-17)
 
 ### Bug fixes

package/dist/index.cjs

@@ -53,13 +53,14 @@ function tokens(frag, encoder, start, end, target) {
   }
   return target;
 }
-var MAX_DIFF_SIZE = 2500;
+var MAX_DIFF_SIZE = 2500,
+  MAX_TOKEN_SIZE = 10000;
 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];
+  if (Math.max(range.toA - range.fromA, range.toB - range.fromB) > MAX_TOKEN_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);
@@ -71,7 +72,8 @@ function diff(tokA, tokB, range, cmp) {
   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)];
+  if (endA == start && endB == start) return [];
+  if (endA == start || endB == start || endA == endB && endA == start + 1 || Math.max(endA, endB) - start > MAX_DIFF_SIZE) return [range.slice(start, endA, start, endB)];
   var lenA = endA - start,
     lenB = endB - start;
   var max = Math.min(MAX_DIFF_SIZE, lenA + lenB);
@@ -134,7 +136,7 @@ function diff(tokA, tokB, range, cmp) {
     }
     if (size % 2 == 0) history.push(frontier.slice());
   }
-  return [range];
+  return [range.slice(start, endA, start, endB)];
 }
 var Span = function () {
   function Span(length, data) {

package/dist/index.d.cts

@@ -183,4 +183,5 @@ declare class ChangeSet<Data = any> {
     static create<Data = any>(doc: Node, combine?: (dataA: Data, dataB: Data) => Data, tokenEncoder?: TokenEncoder<any>, changes?: readonly Change<Data>[]): ChangeSet<Data>;
 }
 
-export { Change, type ChangeJSON, ChangeSet, Span, type TokenEncoder, simplifyChanges };
+export { Change, ChangeSet, Span, simplifyChanges };
+export type { ChangeJSON, TokenEncoder };

package/dist/index.d.ts

@@ -183,4 +183,5 @@ declare class ChangeSet<Data = any> {
     static create<Data = any>(doc: Node, combine?: (dataA: Data, dataB: Data) => Data, tokenEncoder?: TokenEncoder<any>, changes?: readonly Change<Data>[]): ChangeSet<Data>;
 }
 
-export { Change, type ChangeJSON, ChangeSet, Span, type TokenEncoder, simplifyChanges };
+export { Change, ChangeSet, Span, simplifyChanges };
+export type { ChangeJSON, TokenEncoder };

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 = 2500;
+const MAX_DIFF_SIZE = 2500, MAX_TOKEN_SIZE = 10000;
 // 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
@@ -54,7 +54,7 @@ function minUnchanged(sizeA, sizeB) {
 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)
+    if (Math.max(range.toA - range.fromA, range.toB - range.fromB) > MAX_TOKEN_SIZE)
         return [range];
     let tokA = tokens(fragA, encoder, range.fromA, range.toA, []);
     let tokB = tokens(fragB, encoder, range.fromB, range.toB, []);
@@ -69,9 +69,12 @@ function diff(tokA, tokB, range, cmp) {
         return [];
     while (endA > start && endB > start && cmp(tokA[endA - 1], tokB[endB - 1]))
         endA--, endB--;
+    // No difference
+    if (endA == start && endB == start)
+        return [];
     // If the result is simple _or_ too big to cheaply compute, return
     // the remaining region as the diff
-    if (endA == start || endB == start || (endA == endB && endA == start + 1))
+    if (endA == start || endB == start || (endA == endB && endA == start + 1) || Math.max(endA, endB) - start > MAX_DIFF_SIZE)
         return [range.slice(start, endA, start, endB)];
     // This is an implementation of Myers' diff algorithm
     // See https://neil.fraser.name/writing/diff/myers.pdf and
@@ -136,7 +139,7 @@ function diff(tokA, tokB, range, cmp) {
     }
     // The loop exited, meaning the maximum amount of work was done.
     // Just return a change spanning the entire range.
-    return [range];
+    return [range.slice(start, endA, start, endB)];
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prosemirror-changeset",
-  "version": "2.4.3",
+  "version": "2.4.4",
   "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 = 2500
+const MAX_DIFF_SIZE = 2500, MAX_TOKEN_SIZE = 10000
 
 // This obscure mess of constants computes the minimum length of an
 // unchanged range (not at the start/end of the compared content). The
@@ -78,7 +78,7 @@ 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)
+  if (Math.max(range.toA - range.fromA, range.toB - range.fromB) > MAX_TOKEN_SIZE)
     return [range]
   let tokA = tokens(fragA, encoder, range.fromA, range.toA, [])
   let tokB = tokens(fragB, encoder, range.fromB, range.toB, [])
@@ -91,9 +91,11 @@ function diff<T>(tokA: T[], tokB: T[], range: Change, cmp: (a: T, b: T) => boole
   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--
+  // No difference
+  if (endA == start && endB == start) return []
   // If the result is simple _or_ too big to cheaply compute, return
   // the remaining region as the diff
-  if (endA == start || endB == start || (endA == endB && endA == start + 1))
+  if (endA == start || endB == start || (endA == endB && endA == start + 1) || Math.max(endA, endB) - start > MAX_DIFF_SIZE)
     return [range.slice(start, endA, start, endB)]
 
   // This is an implementation of Myers' diff algorithm
@@ -152,5 +154,5 @@ function diff<T>(tokA: T[], tokB: T[], range: Change, cmp: (a: T, b: T) => boole
   }
   // The loop exited, meaning the maximum amount of work was done.
   // Just return a change spanning the entire range.
-  return [range]
+  return [range.slice(start, endA, start, endB)]
 }

package/test/test-diff.ts

@@ -66,4 +66,12 @@ describe("computeDiff", () => {
 
   it("sees the difference between different closing tokens", () =>
      test(doc(p("a")), doc(h1("oo")), [0, 3, 0, 4]))
+
+  it("finds no changes on unchanged content", () =>
+     test(doc(p("abc")), doc(p("abc"))))
+
+  it("can compute a diff for a big change with unchanged prefix/suffix", () =>
+     test(doc(p("x".repeat(2000) + "a" + "y".repeat(2000))),
+          doc(p("x".repeat(2000) + "b" + "y".repeat(2000))),
+          [2001, 2002, 2001, 2002]))
 })