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

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @atlaskit/editor-plugin-show-diff
 
+## 17.0.2
+
+### Patch Changes
+
+- [`df446e0eda630`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/df446e0eda630) -
+  The extended diff view now compares whole tables after a column deletion. Reliably tracked deleted
+  columns use strikethrough text and a Removed lozenge, with contributor tags aligned directly above
+  the table. Deleted table rows also carry a Removed lozenge in their top-right corner.
+- [`885418b21ca4d`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/885418b21ca4d) -
+  Show a struck-through return glyph (⤶) where a removed blank line was — an empty paragraph or an
+  empty heading — instead of rendering nothing. One glyph per removed line, including runs of
+  adjacent ones. Covers both diff directions: the deleted side of a forward diff, and the inserted
+  side of an inverted diff (AI suggested edits). Behind `platform_editor_ai_show_diff_patch_2`.
+- Updated dependencies
+
 ## 17.0.1
 
 ### Patch Changes

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

@@ -15,6 +15,7 @@ var _areDocsEqualByBlockStructureAndText = require("@atlaskit/editor-common/util
 var _document = require("@atlaskit/editor-common/utils/document");
 var _transform = require("@atlaskit/editor-prosemirror/transform");
 var _view = require("@atlaskit/editor-prosemirror/view");
+var _tableMap = require("@atlaskit/editor-tables/table-map");
 var _unsafeExpValNoExposure = require("@atlaskit/platform-feature-experiments/unsafe-exp-val-no-exposure");
 var _fg = require("@atlaskit/platform-feature-flags/fg");
 var _expValEqualsNoExposure = require("@atlaskit/tmp-editor-statsig/exp-val-equals-no-exposure");
@@ -25,15 +26,19 @@ var _createNodeChangedDecorationWidget = require("../decorations/createNodeChang
 var _attributions = require("../decorations/colorSchemes/attributions");
 var _decorationKeys = require("../decorations/decorationKeys");
 var _extractContributorTags = require("../decorations/extractContributorTags");
+var _createDeletedLineBreakWidget = require("../decorations/utils/createDeletedLineBreakWidget");
 var _getAttrChangeRanges = require("../decorations/utils/getAttrChangeRanges");
+var _wrapBlockNodeView = require("../decorations/utils/wrapBlockNodeView");
 var _getMarkChangeRanges = require("../decorations/utils/getMarkChangeRanges");
 var _getScrollableDecorations = require("../getScrollableDecorations");
 var _isExtendedEnabled = require("../isExtendedEnabled");
+var _emptyTextBlocks = require("../utils/emptyTextBlocks");
 var _diffBySteps = require("./diffBySteps");
 var _groupChangesByBlock = require("./groupChangesByBlock");
 var _isMarkOnlyChange = require("./isMarkOnlyChange");
 var _isOpenTokenOnlyChange = require("./isOpenTokenOnlyChange");
 var _optimizeChanges = require("./optimizeChanges");
+var _groupDeletedColumnChanges = require("./groupDeletedColumnChanges");
 var _selectTokenEncoder2 = require("./selectTokenEncoder");
 var _simplifyChangesWithAttribution = require("./simplifyChangesWithAttribution");
 var _simplifySteps = require("./simplifySteps");
@@ -534,10 +539,38 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
 
   // Our default operations are insertions, so it should match the opposite of isInverted.
   var isInserted = !isInverted;
+  if ((0, _isExtendedEnabled.isExtendedEnabled)(diffType)) {
+    changes = (0, _groupDeletedColumnChanges.groupDeletedColumnChanges)(changes, originalDoc, tr.doc, new _transform.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 ? (0, _attributions.getColorSchemeForChange)(change, attributedChanges, attributionColors, colorScheme) : colorScheme;
     var attributionKey = showContributorTags ? (0, _attributions.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.TableMap.get(table);
+      deletedColumns.forEach(function (column) {
+        var offset = tableMap.positionAt(0, column, table);
+        decorations.push(_view.Decoration.widget(change.fromB + _groupDeletedColumnChanges.CELL_CONTENT_OFFSET + offset, function () {
+          return (0, _wrapBlockNodeView.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
@@ -571,6 +604,41 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
       // On an inverted diff the inserted side is visually the deleted side.
       var shouldHideDeleted = (0, _isExtendedEnabled.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 ((0, _fg.fg)('platform_editor_ai_show_diff_patch_2') && !isInserted && !shouldHideDeleted) {
+        var _iterator3 = _createForOfIteratorHelper((0, _emptyTextBlocks.emptyTextBlockContentPositions)(tr.doc, change.fromB, change.toB)),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var pos = _step3.value;
+            decorations.push((0, _createDeletedLineBreakWidget.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
@@ -601,13 +669,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 = (0, _slicedToArray2.default)(_step3.value, 2),
-              from = _step3$value[0],
-              to = _step3$value[1];
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var _step4$value = (0, _slicedToArray2.default)(_step4.value, 2),
+              from = _step4$value[0],
+              to = _step4$value[1];
             if (useCoarseTableDecoration && isInsideTable(coarseTables, from)) {
               continue;
             }
@@ -634,9 +702,9 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
             }))));
           }
         } catch (err) {
-          _iterator3.e(err);
+          _iterator4.e(err);
         } finally {
-          _iterator3.f();
+          _iterator4.f();
         }
       } else {
         decorations.push.apply(decorations, (0, _toConsumableArray2.default)((0, _createInlineChangedDecoration.createInlineChangedDecoration)(_objectSpread({
@@ -688,6 +756,7 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
       });
       if (!_shouldHideDeleted) {
         decorations.push.apply(decorations, (0, _toConsumableArray2.default)((0, _createNodeChangedDecorationWidget.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
@@ -723,6 +792,10 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
   (0, _getMarkChangeRanges.getMarkChangeRanges)(simplifiedSteps, simplifiedStepAttributions, (0, _fg.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 !(0, _fg.fg)('confluence_ncs_step_diffing_version_history') || !changes.some(function (change) {
       return change.fromB === fromB && change.toB === toB;
     });
@@ -744,9 +817,13 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
       tagMountContext: tagMountContext
     })));
   });
-  (0, _getAttrChangeRanges.getAttrChangeRanges)(tr.doc, attrStepContexts, originalDoc).filter(function (_ref12) {
-    var fromB = _ref12.fromB,
-      toB = _ref12.toB;
+  (0, _getAttrChangeRanges.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 !(0, _fg.fg)('confluence_ncs_step_diffing_version_history') || !changes.some(function (change) {
       return change.fromB === fromB && change.toB === toB;
     });
@@ -856,49 +933,49 @@ var calculateDiffDecorationsInner = function calculateDiffDecorationsInner(_ref8
 var calculateDiffDecorations = exports.calculateDiffDecorations = (0, _memoizeOne.default)(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 = (0, _slicedToArray2.default)(_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 = (0, _slicedToArray2.default)(_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 = (0, _slicedToArray2.default)(_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 = (0, _slicedToArray2.default)(_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 ((0, _isExtendedEnabled.isExtendedEnabled)(diffType)) {
-    var _ref17;
-    return (_ref17 = colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isInverted === lastIsInverted && diffType === lastDiffType && (0, _isEqual.default)(activeIndexPos, lastActiveIndexPos) && originalDocIsSame && (0, _isEqual.default)(pluginState.steps, lastPluginState.steps) && (0, _isEqual.default)(pluginState.stepAttributions, lastPluginState.stepAttributions) &&
+    var _ref19;
+    return (_ref19 = colorScheme === lastColorScheme && intl.locale === lastIntl.locale && isInverted === lastIsInverted && diffType === lastDiffType && (0, _isEqual.default)(activeIndexPos, lastActiveIndexPos) && originalDocIsSame && (0, _isEqual.default)(pluginState.steps, lastPluginState.steps) && (0, _isEqual.default)(pluginState.stepAttributions, lastPluginState.stepAttributions) &&
     // Contributors can arrive after the first calculation; without this, tags never appear.
     (0, _isEqual.default)(pluginState.contributors, lastPluginState.contributors) && state.doc.eq(lastState.doc) && hideDeletedDiffs === lastHideDeletedDiffs && hideAddedDiffsUnderline === lastHideAddedDiffsUnderline && showIndicators === lastShowIndicators && (0, _isEqual.default)(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.
-    (0, _isEqual.default)(reveal, lastReveal)) !== null && _ref17 !== void 0 ? _ref17 : false;
+    (0, _isEqual.default)(reveal, lastReveal)) !== null && _ref19 !== void 0 ? _ref19 : false;
   }
-  return (_ref18 = originalDocIsSame && (0, _isEqual.default)(pluginState.steps, lastPluginState.steps) && (0, _isEqual.default)(pluginState.stepAttributions, lastPluginState.stepAttributions) && (0, _isEqual.default)(pluginState.contributors, lastPluginState.contributors) && state.doc.eq(lastState.doc) && colorScheme === lastColorScheme && intl.locale === lastIntl.locale && (0, _isEqual.default)(activeIndexPos, lastActiveIndexPos) && hideDeletedDiffs === lastHideDeletedDiffs) !== null && _ref18 !== void 0 ? _ref18 : false;
+  return (_ref20 = originalDocIsSame && (0, _isEqual.default)(pluginState.steps, lastPluginState.steps) && (0, _isEqual.default)(pluginState.stepAttributions, lastPluginState.stepAttributions) && (0, _isEqual.default)(pluginState.contributors, lastPluginState.contributors) && state.doc.eq(lastState.doc) && colorScheme === lastColorScheme && intl.locale === lastIntl.locale && (0, _isEqual.default)(activeIndexPos, lastActiveIndexPos) && hideDeletedDiffs === lastHideDeletedDiffs) !== null && _ref20 !== void 0 ? _ref20 : false;
 });

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

@@ -0,0 +1,265 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.groupDeletedColumnChanges = exports.CELL_CONTENT_OFFSET = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _document = require("@atlaskit/editor-common/utils/document");
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _tableMap = require("@atlaskit/editor-tables/table-map");
+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; }
+var CELL_CONTENT_OFFSET = exports.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 _model.Slice(_model.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.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 (0, _document.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 = (0, _toConsumableArray2.default)(surviving);
+  return !ordered.some(function (column, index) {
+    return index > 0 && column <= ordered[index - 1];
+  });
+};
+var findDeletedColumns = function findDeletedColumns(before, after, afterToBefore) {
+  var beforeMap = _tableMap.TableMap.get(before.node);
+  var afterMap = _tableMap.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.TableMap.get(before.node).width <= _tableMap.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((0, _toConsumableArray2.default)(change.deleted), (0, _toConsumableArray2.default)(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. */
+var groupDeletedColumnChanges = exports.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 (0, _toConsumableArray2.default)(changes);
+  }
+  return [].concat((0, _toConsumableArray2.default)(changes.filter(function (change) {
+    return !replaced.has(change);
+  })), (0, _toConsumableArray2.default)(plans.map(function (plan) {
+    return plan.tableChange;
+  }))).sort(function (left, right) {
+    return left.fromB - right.fromB;
+  });
+};