@atlaskit/editor-plugin-show-diff 17.0.0 → 17.0.2

package/dist/esm/pm-plugins/calculateDiff/calculateDiffDecorations.js

@@ -12,7 +12,8 @@ import { ChangeSet, simplifyChanges } from 'prosemirror-changeset';
 import { areDocsEqualByBlockStructureAndText } from '@atlaskit/editor-common/utils/areDocsEqualByBlockStructureAndText';
 import { areNodesEqualIgnoreAttrs } from '@atlaskit/editor-common/utils/document';
 import { Mapping } from '@atlaskit/editor-prosemirror/transform';
-import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { TableMap } from '@atlaskit/editor-tables/table-map';
 import { UNSAFE_expValNoExposure } from '@atlaskit/platform-feature-experiments/unsafe-exp-val-no-exposure';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
 import { expValEqualsNoExposure } from '@atlaskit/tmp-editor-statsig/exp-val-equals-no-exposure';
@@ -23,15 +24,19 @@ import { createNodeChangedDecorationWidget } from '../decorations/createNodeChan
 import { createAttributionColorMap, getAttributionKey, getAttributionKeyForChange, getColorSchemeForChange, isAttributionColoringEnabled, isContributorTagsEnabled } from '../decorations/colorSchemes/attributions';
 import { extractDiffDescriptors } from '../decorations/decorationKeys';
 import { extractContributorTags } from '../decorations/extractContributorTags';
+import { createDeletedLineBreakDecoration } from '../decorations/utils/createDeletedLineBreakWidget';
 import { getAttrChangeRanges, stepIsValidAttrChange } from '../decorations/utils/getAttrChangeRanges';
+import { createRemovedLozenge } from '../decorations/utils/wrapBlockNodeView';
 import { getMarkChangeRanges } from '../decorations/utils/getMarkChangeRanges';
 import { getScrollableDecorations } from '../getScrollableDecorations';
 import { getDefaultDiffType, isExtendedEnabled } from '../isExtendedEnabled';
+import { emptyTextBlockContentPositions } from '../utils/emptyTextBlocks';
 import { diffBySteps } from './diffBySteps';
 import { groupChangesByBlock } from './groupChangesByBlock';
 import { isMarkOnlyChange } from './isMarkOnlyChange';
 import { isOpenTokenOnlyChange } from './isOpenTokenOnlyChange';
 import { optimizeChanges } from './optimizeChanges';
+import { CELL_CONTENT_OFFSET, groupDeletedColumnChanges } from './groupDeletedColumnChanges';
 import { selectTokenEncoder } from './selectTokenEncoder';
 import { collapseOverlappingChanges, simplifyChangesWithAttribution } from './simplifyChangesWithAttribution';
 import { simplifySteps, simplifyStepsWithAttribution } from './simplifySteps';
@@ -527,10 +532,38 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
 
   // Our default operations are insertions, so it should match the opposite of isInverted.
   var isInserted = !isInverted;
+  if (isExtendedEnabled(diffType)) {
+    changes = groupDeletedColumnChanges(changes, originalDoc, tr.doc, new Mapping(stepMaps), isInverted);
+  }
+  // A whole-table change owns every mark and attribute range inside its bounds, so those ranges
+  // do not also get their own decoration.
+  var tableChanges = changes.filter(function (change) {
+    return change.deletedColumns !== undefined;
+  });
+  var isHandledByTable = function isHandledByTable(from, to) {
+    return tableChanges.some(function (change) {
+      return from >= change.fromB && to <= change.toB;
+    });
+  };
   var createDecorationsForChange = function createDecorationsForChange(change) {
     var changeColorScheme = attributionColors ? getColorSchemeForChange(change, attributedChanges, attributionColors, colorScheme) : colorScheme;
     var attributionKey = showContributorTags ? getAttributionKeyForChange(change, attributedChanges) : undefined;
     var isActive = isRangeActive(activeIndexPos, change.fromB, change.toB);
+    var deletedColumns = change.deletedColumns;
+    // On an inverted diff the table that lost columns is the one in `tr.doc`, so the column
+    // indices address it directly and each label anchors inside its own cell.
+    var table = tr.doc.nodeAt(change.fromB);
+    if (isInverted && !hideDeletedDiffs && deletedColumns !== null && deletedColumns !== void 0 && deletedColumns.length && (table === null || table === void 0 ? void 0 : table.type.name) === 'table') {
+      var tableMap = TableMap.get(table);
+      deletedColumns.forEach(function (column) {
+        var offset = tableMap.positionAt(0, column, table);
+        decorations.push(Decoration.widget(change.fromB + CELL_CONTENT_OFFSET + offset, function () {
+          return createRemovedLozenge(intl, isActive, changeColorScheme, true);
+        }, {
+          side: -1
+        }));
+      });
+    }
 
     // The deleted side of a mark-only change is a byte-identical copy of the new text, so it is
     // suppressed in the clean view. `hideDeletedDiffs` is load-bearing: when false the reviewer
@@ -564,6 +597,41 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
       // On an inverted diff the inserted side is visually the deleted side.
       var shouldHideDeleted = isExtendedEnabled(diffType) ? isInverted && hideDeletedDiffs : false;
 
+      // A removed blank line — an empty paragraph or heading — has nothing to mark up. On an
+      // inverted diff, the shape AI suggested edits renders, the block is still in the displayed
+      // document, so the removal lands here on the inserted side rather than on the deleted side,
+      // and both the inline and the block decoration paint nothing: an empty textblock has no
+      // inline content to cover, and block decorations return no style for a paragraph or heading.
+      // The reviewer sees an unmarked blank line. Stand the struck-through return glyph in for each
+      // one, anchored inside the block so it renders on the blank line itself.
+      //
+      // One decoration per blank line rather than one per change: a run of adjacent blank lines is
+      // reported as a single change spanning all of them.
+      //
+      // Withheld in the clean view, where removals are hidden rather than struck through.
+      if (fg('platform_editor_ai_show_diff_patch_2') && !isInserted && !shouldHideDeleted) {
+        var _iterator3 = _createForOfIteratorHelper(emptyTextBlockContentPositions(tr.doc, change.fromB, change.toB)),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var pos = _step3.value;
+            decorations.push(createDeletedLineBreakDecoration({
+              attributionKey: attributionKey,
+              colorScheme: changeColorScheme,
+              diffType: diffType,
+              isActive: isActive,
+              pos: pos,
+              reveal: reveal,
+              side: -1
+            }));
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+      }
+
       // For `smart` NODE-level promotions the change range spans a whole container
       // (e.g. an entire list/table/layout, using outer node bounds). Applying a SINGLE
       // inline decoration across that whole range would paint the inserted style across
@@ -594,13 +662,13 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
         // table (the cell overlays added below provide the highlight without the
         // expensive content re-render); leaf blocks outside the table still get theirs.
         var coarseTables = useCoarseTableDecoration ? tableRanges(tr.doc, change.fromB, change.toB) : [];
-        var _iterator3 = _createForOfIteratorHelper(leafTextblockRanges(tr.doc, change.fromB, change.toB)),
-          _step3;
+        var _iterator4 = _createForOfIteratorHelper(leafTextblockRanges(tr.doc, change.fromB, change.toB)),
+          _step4;
         try {
-          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-            var _step3$value = _slicedToArray(_step3.value, 2),
-              from = _step3$value[0],
-              to = _step3$value[1];
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var _step4$value = _slicedToArray(_step4.value, 2),
+              from = _step4$value[0],
+              to = _step4$value[1];
             if (useCoarseTableDecoration && isInsideTable(coarseTables, from)) {
               continue;
             }
@@ -627,9 +695,9 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
             }))));
           }
         } catch (err) {
-          _iterator3.e(err);
+          _iterator4.e(err);
         } finally {
-          _iterator3.f();
+          _iterator4.f();
         }
       } else {
         decorations.push.apply(decorations, _toConsumableArray(createInlineChangedDecoration(_objectSpread({
@@ -681,6 +749,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
       });
       if (!_shouldHideDeleted) {
         decorations.push.apply(decorations, _toConsumableArray(createNodeChangedDecorationWidget(_objectSpread(_objectSpread({
+          deletedColumns: deletedColumns,
           // The deleted side has no inline decoration, so the widget carries the actor.
           attributionKey: attributionKey,
           // Extended pipeline only, matching the inline path: the non-extended styles have no
@@ -716,6 +785,10 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
   getMarkChangeRanges(simplifiedSteps, simplifiedStepAttributions, fg('confluence_ncs_step_diffing_version_history') ? stepMaps : undefined).filter(function (_ref11) {
     var fromB = _ref11.fromB,
       toB = _ref11.toB;
+    return !isHandledByTable(fromB, toB);
+  }).filter(function (_ref12) {
+    var fromB = _ref12.fromB,
+      toB = _ref12.toB;
     return !fg('confluence_ncs_step_diffing_version_history') || !changes.some(function (change) {
       return change.fromB === fromB && change.toB === toB;
     });
@@ -737,9 +810,13 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
       tagMountContext: tagMountContext
     })));
   });
-  getAttrChangeRanges(tr.doc, attrStepContexts, originalDoc).filter(function (_ref12) {
-    var fromB = _ref12.fromB,
-      toB = _ref12.toB;
+  getAttrChangeRanges(tr.doc, attrStepContexts, originalDoc).filter(function (_ref13) {
+    var fromB = _ref13.fromB,
+      toB = _ref13.toB;
+    return !isHandledByTable(fromB, toB);
+  }).filter(function (_ref14) {
+    var fromB = _ref14.fromB,
+      toB = _ref14.toB;
     return !fg('confluence_ncs_step_diffing_version_history') || !changes.some(function (change) {
       return change.fromB === fromB && change.toB === toB;
     });
@@ -849,49 +926,49 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
 export var calculateDiffDecorations = memoizeOne(calculateDiffDecorationsInner,
 // Cache results unless relevant inputs change. `tagMountContext` is deliberately absent: it is
 // built once per plugin instance, so it can never be the reason a diff needs recalculating.
-function (_ref13, _ref14) {
-  var _ref18;
-  var _ref15 = _slicedToArray(_ref13, 1),
-    _ref15$ = _ref15[0],
-    pluginState = _ref15$.pluginState,
-    state = _ref15$.state,
-    colorScheme = _ref15$.colorScheme,
-    intl = _ref15$.intl,
-    activeIndexPos = _ref15$.activeIndexPos,
-    isInverted = _ref15$.isInverted,
-    diffType = _ref15$.diffType,
-    hideDeletedDiffs = _ref15$.hideDeletedDiffs,
-    hideAddedDiffsUnderline = _ref15$.hideAddedDiffsUnderline,
-    showIndicators = _ref15$.showIndicators,
-    smartThresholds = _ref15$.smartThresholds,
-    deletedDiffPlacement = _ref15$.deletedDiffPlacement,
-    inlineDeletedDiffPlacement = _ref15$.inlineDeletedDiffPlacement,
-    reveal = _ref15$.reveal;
-  var _ref16 = _slicedToArray(_ref14, 1),
-    _ref16$ = _ref16[0],
-    lastPluginState = _ref16$.pluginState,
-    lastState = _ref16$.state,
-    lastColorScheme = _ref16$.colorScheme,
-    lastIntl = _ref16$.intl,
-    lastActiveIndexPos = _ref16$.activeIndexPos,
-    lastIsInverted = _ref16$.isInverted,
-    lastDiffType = _ref16$.diffType,
-    lastHideDeletedDiffs = _ref16$.hideDeletedDiffs,
-    lastHideAddedDiffsUnderline = _ref16$.hideAddedDiffsUnderline,
-    lastShowIndicators = _ref16$.showIndicators,
-    lastSmartThresholds = _ref16$.smartThresholds,
-    lastDeletedDiffPlacement = _ref16$.deletedDiffPlacement,
-    lastInlineDeletedDiffPlacement = _ref16$.inlineDeletedDiffPlacement,
-    lastReveal = _ref16$.reveal;
+function (_ref15, _ref16) {
+  var _ref20;
+  var _ref17 = _slicedToArray(_ref15, 1),
+    _ref17$ = _ref17[0],
+    pluginState = _ref17$.pluginState,
+    state = _ref17$.state,
+    colorScheme = _ref17$.colorScheme,
+    intl = _ref17$.intl,
+    activeIndexPos = _ref17$.activeIndexPos,
+    isInverted = _ref17$.isInverted,
+    diffType = _ref17$.diffType,
+    hideDeletedDiffs = _ref17$.hideDeletedDiffs,
+    hideAddedDiffsUnderline = _ref17$.hideAddedDiffsUnderline,
+    showIndicators = _ref17$.showIndicators,
+    smartThresholds = _ref17$.smartThresholds,
+    deletedDiffPlacement = _ref17$.deletedDiffPlacement,
+    inlineDeletedDiffPlacement = _ref17$.inlineDeletedDiffPlacement,
+    reveal = _ref17$.reveal;
+  var _ref18 = _slicedToArray(_ref16, 1),
+    _ref18$ = _ref18[0],
+    lastPluginState = _ref18$.pluginState,
+    lastState = _ref18$.state,
+    lastColorScheme = _ref18$.colorScheme,
+    lastIntl = _ref18$.intl,
+    lastActiveIndexPos = _ref18$.activeIndexPos,
+    lastIsInverted = _ref18$.isInverted,
+    lastDiffType = _ref18$.diffType,
+    lastHideDeletedDiffs = _ref18$.hideDeletedDiffs,
+    lastHideAddedDiffsUnderline = _ref18$.hideAddedDiffsUnderline,
+    lastShowIndicators = _ref18$.showIndicators,
+    lastSmartThresholds = _ref18$.smartThresholds,
+    lastDeletedDiffPlacement = _ref18$.deletedDiffPlacement,
+    lastInlineDeletedDiffPlacement = _ref18$.inlineDeletedDiffPlacement,
+    lastReveal = _ref18$.reveal;
   var originalDocIsSame = lastPluginState.originalDoc && pluginState.originalDoc && pluginState.originalDoc.eq(lastPluginState.originalDoc);
   if (isExtendedEnabled(diffType)) {
-    var _ref17;
-    return (_ref17 = colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isInverted === lastIsInverted && diffType === lastDiffType && isEqual(activeIndexPos, lastActiveIndexPos) && originalDocIsSame && isEqual(pluginState.steps, lastPluginState.steps) && isEqual(pluginState.stepAttributions, lastPluginState.stepAttributions) &&
+    var _ref19;
+    return (_ref19 = colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isInverted === lastIsInverted && diffType === lastDiffType && isEqual(activeIndexPos, lastActiveIndexPos) && originalDocIsSame && isEqual(pluginState.steps, lastPluginState.steps) && isEqual(pluginState.stepAttributions, lastPluginState.stepAttributions) &&
     // Contributors can arrive after the first calculation; without this, tags never appear.
     isEqual(pluginState.contributors, lastPluginState.contributors) && state.doc.eq(lastState.doc) && hideDeletedDiffs === lastHideDeletedDiffs && hideAddedDiffsUnderline === lastHideAddedDiffsUnderline && showIndicators === lastShowIndicators && isEqual(smartThresholds, lastSmartThresholds) && deletedDiffPlacement === lastDeletedDiffPlacement && inlineDeletedDiffPlacement === lastInlineDeletedDiffPlacement &&
     // Turning the reveal on or off changes the emitted styles, so a cached result from the
     // other setting would leave the diff painted in the wrong resting state.
-    isEqual(reveal, lastReveal)) !== null && _ref17 !== void 0 ? _ref17 : false;
+    isEqual(reveal, lastReveal)) !== null && _ref19 !== void 0 ? _ref19 : false;
   }
-  return (_ref18 = originalDocIsSame && isEqual(pluginState.steps, lastPluginState.steps) && isEqual(pluginState.stepAttributions, lastPluginState.stepAttributions) && isEqual(pluginState.contributors, lastPluginState.contributors) && state.doc.eq(lastState.doc) && colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isEqual(activeIndexPos, lastActiveIndexPos) && hideDeletedDiffs === lastHideDeletedDiffs) !== null && _ref18 !== void 0 ? _ref18 : false;
+  return (_ref20 = originalDocIsSame && isEqual(pluginState.steps, lastPluginState.steps) && isEqual(pluginState.stepAttributions, lastPluginState.stepAttributions) && isEqual(pluginState.contributors, lastPluginState.contributors) && state.doc.eq(lastState.doc) && colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isEqual(activeIndexPos, lastActiveIndexPos) && hideDeletedDiffs === lastHideDeletedDiffs) !== null && _ref20 !== void 0 ? _ref20 : false;
 });

package/dist/esm/pm-plugins/calculateDiff/groupDeletedColumnChanges.js

@@ -0,0 +1,258 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, 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 o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { areNodesEqualIgnoreAttrs } from '@atlaskit/editor-common/utils/document';
+import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+export var CELL_CONTENT_OFFSET = 2;
+var IGNORED_CELL_ATTRS = ['localId', 'colwidth'];
+var tablesIn = function tablesIn(doc) {
+  var tables = [];
+  doc.descendants(function (node, pos) {
+    if (node.type.name === 'table') {
+      tables.push({
+        node: node,
+        pos: pos
+      });
+      return false;
+    }
+    return true;
+  });
+  return tables;
+};
+var tableEnd = function tableEnd(table) {
+  return table.pos + table.node.nodeSize;
+};
+var documentsDifferOnlyByTable = function documentsDifferOnlyByTable(originalDoc, newDoc, before, after) {
+  try {
+    return originalDoc.replace(before.pos, tableEnd(before), new Slice(Fragment.from(after.node), 0, 0)).eq(newDoc);
+  } catch (_unused) {
+    return false;
+  }
+};
+var columnOffsets = function columnOffsets(map, table) {
+  return Array.from({
+    length: map.width
+  }, function (_, column) {
+    return map.positionAt(0, column, table);
+  });
+};
+var positionMatchedColumns = function positionMatchedColumns(_ref) {
+  var before = _ref.before,
+    after = _ref.after,
+    afterToBefore = _ref.afterToBefore,
+    beforeOffsets = _ref.beforeOffsets;
+  var afterMap = TableMap.get(after.node);
+  var surviving = new Set();
+  for (var column = 0; column < afterMap.width; column++) {
+    var offset = afterMap.positionAt(0, column, after.node);
+    var mapped = afterToBefore.mapResult(after.pos + CELL_CONTENT_OFFSET + offset);
+    var beforeColumn = beforeOffsets.indexOf(mapped.pos - before.pos - CELL_CONTENT_OFFSET);
+    if (mapped.deleted || beforeColumn === -1) {
+      return new Set();
+    }
+    surviving.add(beforeColumn);
+  }
+  return surviving;
+};
+var addContentMatchedColumns = function addContentMatchedColumns(surviving, before, after) {
+  var _before$node$firstChi, _before$node$firstChi2, _after$node$firstChil, _after$node$firstChil2;
+  var beforeCells = (_before$node$firstChi = (_before$node$firstChi2 = before.node.firstChild) === null || _before$node$firstChi2 === void 0 ? void 0 : _before$node$firstChi2.children) !== null && _before$node$firstChi !== void 0 ? _before$node$firstChi : [];
+  var afterCells = (_after$node$firstChil = (_after$node$firstChil2 = after.node.firstChild) === null || _after$node$firstChil2 === void 0 ? void 0 : _after$node$firstChil2.children) !== null && _after$node$firstChil !== void 0 ? _after$node$firstChil : [];
+  var _iterator = _createForOfIteratorHelper(afterCells),
+    _step;
+  try {
+    var _loop = function _loop() {
+        var afterCell = _step.value;
+        var matches = beforeCells.flatMap(function (beforeCell, column) {
+          return areNodesEqualIgnoreAttrs(beforeCell, afterCell, IGNORED_CELL_ATTRS) ? [column] : [];
+        });
+        if (matches.length !== 1) {
+          return {
+            v: false
+          };
+        }
+        surviving.add(matches[0]);
+      },
+      _ret;
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _ret = _loop();
+      if (_ret) return _ret.v;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var ordered = _toConsumableArray(surviving);
+  return !ordered.some(function (column, index) {
+    return index > 0 && column <= ordered[index - 1];
+  });
+};
+var findDeletedColumns = function findDeletedColumns(before, after, afterToBefore) {
+  var beforeMap = TableMap.get(before.node);
+  var afterMap = TableMap.get(after.node);
+  // Merged or malformed tables do not have reliable column indices.
+  if (beforeMap.hasMergedCells() || afterMap.hasMergedCells() || beforeMap.problems || afterMap.problems) {
+    return [];
+  }
+  var beforeOffsets = columnOffsets(beforeMap, before.node);
+  var surviving = positionMatchedColumns({
+    before: before,
+    after: after,
+    afterToBefore: afterToBefore,
+    beforeOffsets: beforeOffsets
+  });
+  if (surviving.size !== afterMap.width && !addContentMatchedColumns(surviving, before, after)) {
+    return [];
+  }
+  return beforeOffsets.flatMap(function (_, column) {
+    return surviving.has(column) ? [] : [column];
+  });
+};
+var findCounterpart = function findCounterpart(_ref2) {
+  var table = _ref2.table,
+    index = _ref2.index,
+    originalTables = _ref2.originalTables,
+    newTables = _ref2.newTables,
+    mapping = _ref2.mapping;
+  var from = mapping.map(table.pos, -1);
+  var to = mapping.map(tableEnd(table), 1);
+  var inside = mapping.mapResult(table.pos + 1);
+  var candidates = newTables.filter(function (candidate) {
+    return inside.deleted ? candidate.pos >= from && tableEnd(candidate) <= to : candidate.pos < inside.pos && inside.pos < tableEnd(candidate);
+  });
+  if (candidates.length === 1) {
+    return candidates[0];
+  }
+  return originalTables.length === newTables.length ? newTables[index] : undefined;
+};
+var orient = function orient(_ref3) {
+  var table = _ref3.table,
+    counterpart = _ref3.counterpart,
+    mapping = _ref3.mapping,
+    isInverted = _ref3.isInverted;
+  return {
+    before: isInverted ? counterpart : table,
+    after: isInverted ? table : counterpart,
+    afterToBefore: (isInverted ? mapping.invert() : mapping).invert()
+  };
+};
+var changesInTable = function changesInTable(changes, table) {
+  return changes.filter(function (change) {
+    return change.fromA < tableEnd(table) && change.toA > table.pos;
+  });
+};
+var isNarrowingSafe = function isNarrowingSafe(_ref4) {
+  var replacedChanges = _ref4.replacedChanges,
+    table = _ref4.table,
+    counterpart = _ref4.counterpart,
+    originalDoc = _ref4.originalDoc,
+    newDoc = _ref4.newDoc;
+  var staysInside = replacedChanges.every(function (change) {
+    return change.fromA >= table.pos && change.toA <= tableEnd(table) && change.fromB >= counterpart.pos && change.toB <= tableEnd(counterpart);
+  });
+  return staysInside || documentsDifferOnlyByTable(originalDoc, newDoc, table, counterpart);
+};
+var planTableChange = function planTableChange(_ref5) {
+  var table = _ref5.table,
+    index = _ref5.index,
+    originalTables = _ref5.originalTables,
+    newTables = _ref5.newTables,
+    changes = _ref5.changes,
+    originalDoc = _ref5.originalDoc,
+    newDoc = _ref5.newDoc,
+    mapping = _ref5.mapping,
+    isInverted = _ref5.isInverted;
+  var counterpart = findCounterpart({
+    table: table,
+    index: index,
+    originalTables: originalTables,
+    newTables: newTables,
+    mapping: mapping
+  });
+  if (!counterpart) {
+    return undefined;
+  }
+  var _orient = orient({
+      table: table,
+      counterpart: counterpart,
+      mapping: mapping,
+      isInverted: isInverted
+    }),
+    before = _orient.before,
+    after = _orient.after,
+    afterToBefore = _orient.afterToBefore;
+  if (TableMap.get(before.node).width <= TableMap.get(after.node).width) {
+    return undefined;
+  }
+  var replacedChanges = changesInTable(changes, table);
+  if (!replacedChanges.length) {
+    return undefined;
+  }
+  if (!isNarrowingSafe({
+    replacedChanges: replacedChanges,
+    table: table,
+    counterpart: counterpart,
+    originalDoc: originalDoc,
+    newDoc: newDoc
+  })) {
+    return undefined;
+  }
+  var spans = replacedChanges.flatMap(function (change) {
+    return [].concat(_toConsumableArray(change.deleted), _toConsumableArray(change.inserted));
+  });
+  return {
+    replacedChanges: replacedChanges,
+    tableChange: {
+      deletedColumns: findDeletedColumns(before, after, afterToBefore),
+      fromA: table.pos,
+      toA: tableEnd(table),
+      fromB: counterpart.pos,
+      toB: tableEnd(counterpart),
+      deleted: spans,
+      inserted: spans
+    }
+  };
+};
+
+/** Groups a deleted column's cell changes into one whole-table change. */
+export var groupDeletedColumnChanges = function groupDeletedColumnChanges(changes, originalDoc, newDoc, mapping, isInverted) {
+  var originalTables = tablesIn(originalDoc);
+  var newTables = tablesIn(newDoc);
+  var plans = [];
+  var replaced = new Set();
+  originalTables.forEach(function (table, index) {
+    var plan = planTableChange({
+      table: table,
+      index: index,
+      originalTables: originalTables,
+      newTables: newTables,
+      changes: changes.filter(function (change) {
+        return !replaced.has(change);
+      }),
+      originalDoc: originalDoc,
+      newDoc: newDoc,
+      mapping: mapping,
+      isInverted: isInverted
+    });
+    if (!plan) {
+      return;
+    }
+    plans.push(plan);
+    plan.replacedChanges.forEach(function (change) {
+      return replaced.add(change);
+    });
+  });
+  if (!plans.length) {
+    return _toConsumableArray(changes);
+  }
+  return [].concat(_toConsumableArray(changes.filter(function (change) {
+    return !replaced.has(change);
+  })), _toConsumableArray(plans.map(function (plan) {
+    return plan.tableChange;
+  }))).sort(function (left, right) {
+    return left.fromB - right.fromB;
+  });
+};