@atlaskit/editor-plugin-show-diff 10.1.23 → 10.2.0

package/dist/esm/pm-plugins/calculateDiff/smart/helpers.js

@@ -0,0 +1,128 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _typeof from "@babel/runtime/helpers/typeof";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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; }
+/**
+ * The granularity level a `smart` change was promoted to. Stored on span `data` so the
+ * decoration pipeline can render each level differently (e.g. node-level deletions shown
+ * below the new content). `null` for non-promoted (inline) changes.
+ */
+
+/** Span `data` payload carried by promoted `smart` changes. */
+
+/**
+ * Build the `deleted`/`inserted` span arrays a `Change` needs. A length of 0 yields an
+ * empty array (no change on that side).
+ */
+export var createSpans = function createSpans(length) {
+  var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return length > 0 ? [{
+    length: length,
+    data: data
+  }] : [];
+};
+
+/**
+ * Build a promoted `Change` spanning `[fromA,toA)` in the original doc and `[fromB,toB)`
+ * in the new doc, with both sides marked changed (mirrors `groupChangesByBlock` so the
+ * decoration pipeline renders both the inserted-block decoration and the deleted-node
+ * widget).
+ *
+ * `level` tags the change's spans so downstream decoration logic can treat node-level
+ * promotions specially (see `smartChangeLevel`).
+ */
+export var makePromotedChange = function makePromotedChange(fromA, toA, fromB, toB, level) {
+  var data = level ? {
+    smartLevel: level
+  } : null;
+  // `deleted` and `inserted` must be independent arrays: downstream code may mutate one
+  // side (push/splice), which would silently corrupt the other if they shared a reference.
+  return {
+    fromA: fromA,
+    toA: toA,
+    fromB: fromB,
+    toB: toB,
+    deleted: createSpans(Math.max(0, toA - fromA), data),
+    inserted: createSpans(Math.max(0, toB - fromB), data)
+  };
+};
+
+/**
+ * Read the `smartLevel` tag off a change's spans, if present. Returns `undefined` for
+ * changes not produced by the `smart` classifier (e.g. inline/block/step diff types).
+ */
+export var smartChangeLevel = function smartChangeLevel(change) {
+  var spans = [].concat(_toConsumableArray(change.inserted), _toConsumableArray(change.deleted));
+  var _iterator = _createForOfIteratorHelper(spans),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var span = _step.value;
+      var data = span.data;
+      if (data && _typeof(data) === 'object' && 'smartLevel' in data) {
+        return data.smartLevel;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return undefined;
+};
+
+/** True when a change has no original-side (deleted) content — a pure insertion. */
+var isPureInsertion = function isPureInsertion(change) {
+  return change.toA <= change.fromA;
+};
+
+/**
+ * Coalesce changes that overlap in new-doc (B) coordinates.
+ *
+ * Merging two changes takes the UNION of their A (original-doc) ranges. That is only safe when
+ * their A ranges actually touch/overlap — OR when at least one is a pure insertion (empty A).
+ * Otherwise, merging a deletion at A[110,152] with a later edit at A[162,168] would fabricate an
+ * A span [110,168] covering the untouched gap, which then overlaps a *different* change's A range
+ * (making the same original content appear deleted twice). So we require B-overlap AND
+ * (A-overlap OR a pure insertion) before coalescing.
+ */
+export var mergeOverlappingByNewDocRange = function mergeOverlappingByNewDocRange(changes) {
+  if (changes.length <= 1) {
+    return changes;
+  }
+  var sorted = _toConsumableArray(changes).sort(function (l, r) {
+    return l.fromB - r.fromB;
+  });
+  var merged = [];
+  var current = _objectSpread({}, sorted[0]);
+  for (var i = 1; i < sorted.length; i++) {
+    var next = sorted[i];
+    var bOverlaps = next.fromB <= current.toB;
+    // A ranges may be unioned only if they touch, or if either side contributes no A content.
+    var aMergeable = isPureInsertion(current) || isPureInsertion(next) || rangesOverlap(current.fromA, current.toA, next.fromA, next.toA) || next.fromA <= current.toA; // adjacency (sorted by B, A usually monotonic)
+    if (bOverlaps && aMergeable) {
+      current = {
+        fromA: Math.min(current.fromA, next.fromA),
+        toA: Math.max(current.toA, next.toA),
+        fromB: Math.min(current.fromB, next.fromB),
+        toB: Math.max(current.toB, next.toB),
+        deleted: [].concat(_toConsumableArray(current.deleted), _toConsumableArray(next.deleted)),
+        inserted: [].concat(_toConsumableArray(current.inserted), _toConsumableArray(next.inserted))
+      };
+    } else {
+      merged.push(current);
+      current = _objectSpread({}, next);
+    }
+  }
+  merged.push(current);
+  return merged;
+};
+
+/** True when two half-open ranges overlap. */
+export var rangesOverlap = function rangesOverlap(aFrom, aTo, bFrom, bTo) {
+  return aFrom < bTo && bFrom < aTo;
+};

package/dist/esm/pm-plugins/calculateDiff/smart/segmentText.js

@@ -0,0 +1,325 @@
+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; }
+/**
+ * A half-open offset span `[from, to)` measured in *content offsets* relative to the
+ * start of a textblock (i.e. the same coordinate space as `buildCharsByOffset`).
+ */
+
+/**
+ * Minimal local typing for `Intl.Segmenter`. The TS lib target configured for this
+ * package does not include the `Intl.Segmenter` declarations, so we declare just the
+ * surface we use and access it via a runtime-checked cast. Remove when the lib target is
+ * bumped to include `es2022.intl`/`esnext.intl`.
+ */
+
+// A character is treated as part of a word unless it is whitespace or common punctuation.
+// We deliberately avoid Unicode property escapes (`\p{...}`) and the `u` flag here: the `u`
+// flag is only valid when targeting es6+, and the declaration-generation build config for
+// this package targets an older lib, which rejects it with TS1501. This negated approach
+// keeps word segmentation reasonable across scripts (any non-punctuation, non-space glyph
+// counts as a word char) without needing Unicode-aware regex.
+var NON_WORD_CHARS = ' \t\n\r\f\v.,;:!?…。！？、"\'`“”‘’()[]{}<>/\\|@#$%^&*-+=~';
+var NON_WORD_CHAR_SET = new Set(NON_WORD_CHARS.split(''));
+var isWordChar = function isWordChar(ch) {
+  return !NON_WORD_CHAR_SET.has(ch);
+};
+// Whitespace is checked via a Set rather than a regex to avoid both the `require-unicode-regexp`
+// lint rule and the TS1501 error the `u` flag triggers under this package's build lib target.
+var WHITESPACE_CHAR_SET = new Set([' ', '\t', '\n', '\r', '\f', '\v', "\xA0"]);
+var isWhitespaceChar = function isWhitespaceChar(ch) {
+  return WHITESPACE_CHAR_SET.has(ch);
+};
+// Sentence terminators used by the regex fallback. We intentionally keep this small and
+// conservative — the Intl.Segmenter path is the source of truth when available.
+var SENTENCE_TERMINATORS = new Set(['.', '!', '?', '…', '。', '！', '？']);
+
+/**
+ * Build a per-content-offset view of a textblock's characters.
+ *
+ * `chars[i]` is the character at content offset `i`, or `null` when that offset lies
+ * inside a non-text inline node (mention, date, emoji, hardBreak, …). A `null` acts as an
+ * *opaque single token*: it counts as one word and never terminates a sentence.
+ */
+export var buildCharsByOffset = function buildCharsByOffset(parent) {
+  var chars = Array.from({
+    length: parent.content.size
+  }, function () {
+    return null;
+  });
+  parent.content.forEach(function (child, offset) {
+    var _child$text;
+    if (!child.isText) {
+      return;
+    }
+    var text = (_child$text = child.text) !== null && _child$text !== void 0 ? _child$text : '';
+    for (var i = 0; i < text.length; i++) {
+      chars[offset + i] = text[i];
+    }
+  });
+  return chars;
+};
+var getSegmenterCtor = function getSegmenterCtor() {
+  if (typeof Intl === 'undefined') {
+    return undefined;
+  }
+  var ctor = Intl.Segmenter;
+  return typeof ctor === 'function' ? ctor : undefined;
+};
+var cachedLocale;
+var cachedSentenceSegmenter;
+var cachedWordSegmenter;
+var getSegmenters = function getSegmenters(locale) {
+  var Ctor = getSegmenterCtor();
+  if (!Ctor) {
+    return undefined;
+  }
+  if (cachedLocale !== locale || !cachedSentenceSegmenter || !cachedWordSegmenter) {
+    cachedLocale = locale;
+    cachedSentenceSegmenter = new Ctor(locale, {
+      granularity: 'sentence'
+    });
+    cachedWordSegmenter = new Ctor(locale, {
+      granularity: 'word'
+    });
+  }
+  return {
+    sentence: cachedSentenceSegmenter,
+    word: cachedWordSegmenter
+  };
+};
+
+/**
+ * Convert a char-view into a plain string plus an index map back to content offsets.
+ *
+ * Opaque inline tokens (`null`) are represented in the string by a single sentinel
+ * character (Unicode Object Replacement Character, U+FFFC) so that:
+ * - the segmenter treats them as a word-like glyph rather than whitespace/punctuation;
+ * - they never look like a sentence terminator.
+ * `indexMap[j]` gives the content offset of string index `j`.
+ */
+var OBJECT_REPLACEMENT = "\uFFFC";
+var flattenChars = function flattenChars(chars) {
+  var text = '';
+  var indexMap = [];
+  for (var offset = 0; offset < chars.length; offset++) {
+    var ch = chars[offset];
+    text += ch === null ? OBJECT_REPLACEMENT : ch;
+    indexMap.push(offset);
+  }
+  return {
+    text: text,
+    indexMap: indexMap
+  };
+};
+var stringIndexToOffset = function stringIndexToOffset(indexMap, strIdx, fallback) {
+  if (strIdx < 0) {
+    return fallback;
+  }
+  if (strIdx >= indexMap.length) {
+    // One-past-the-end maps to the offset after the last char.
+    return indexMap.length > 0 ? indexMap[indexMap.length - 1] + 1 : fallback;
+  }
+  return indexMap[strIdx];
+};
+
+/**
+ * Segment a textblock char-view into sentence spans (content-offset coordinates).
+ * Uses Intl.Segmenter when available, otherwise a conservative regex fallback.
+ */
+export var segmentSentences = function segmentSentences(chars, locale) {
+  if (chars.length === 0) {
+    return [];
+  }
+  var _flattenChars = flattenChars(chars),
+    text = _flattenChars.text,
+    indexMap = _flattenChars.indexMap;
+  var segmenters = getSegmenters(locale);
+  if (segmenters) {
+    var _spans = [];
+    var _iterator = _createForOfIteratorHelper(segmenters.sentence.segment(text)),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var seg = _step.value;
+        var startOffset = stringIndexToOffset(indexMap, seg.index, 0);
+        var endOffset = stringIndexToOffset(indexMap, seg.index + seg.segment.length, chars.length);
+        if (endOffset > startOffset) {
+          _spans.push({
+            from: startOffset,
+            to: endOffset
+          });
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return _spans.length > 0 ? _spans : [{
+      from: 0,
+      to: chars.length
+    }];
+  }
+
+  // Regex fallback: split after a sentence terminator followed by whitespace/EOL.
+  // A `null` (OBJECT_REPLACEMENT) is never a terminator.
+  var spans = [];
+  var start = 0;
+  for (var i = 0; i < chars.length; i++) {
+    var ch = chars[i];
+    if (ch !== null && SENTENCE_TERMINATORS.has(ch)) {
+      // Consume trailing spaces as part of this sentence.
+      var end = i + 1;
+      while (end < chars.length && chars[end] !== null && isWhitespaceChar(chars[end])) {
+        end++;
+      }
+      spans.push({
+        from: start,
+        to: end
+      });
+      start = end;
+    }
+  }
+  if (start < chars.length) {
+    spans.push({
+      from: start,
+      to: chars.length
+    });
+  }
+  return spans.length > 0 ? spans : [{
+    from: 0,
+    to: chars.length
+  }];
+};
+
+/**
+ * Count word-like tokens within a content-offset range of the char-view.
+ * Each opaque inline token (`null`) counts as exactly one word.
+ */
+export var countWords = function countWords(chars, span, locale) {
+  var slice = chars.slice(span.from, span.to);
+  if (slice.length === 0) {
+    return 0;
+  }
+  var segmenters = getSegmenters(locale);
+  var _flattenChars2 = flattenChars(slice),
+    text = _flattenChars2.text;
+  if (segmenters) {
+    var _count = 0;
+    var _iterator2 = _createForOfIteratorHelper(segmenters.word.segment(text)),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var seg = _step2.value;
+        // Object-replacement sentinel is word-like; count it.
+        if (seg.isWordLike || seg.segment.includes(OBJECT_REPLACEMENT)) {
+          _count++;
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    return _count;
+  }
+
+  // Regex fallback: a run of word chars OR a single opaque token is one word.
+  var count = 0;
+  var inWord = false;
+  var _iterator3 = _createForOfIteratorHelper(slice),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var ch = _step3.value;
+      if (ch === null) {
+        count++;
+        inWord = false;
+        continue;
+      }
+      if (isWordChar(ch)) {
+        if (!inWord) {
+          count++;
+          inWord = true;
+        }
+      } else {
+        inWord = false;
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return count;
+};
+
+/**
+ * Return the word-token spans (content-offset coordinates) within a range. Used to decide
+ * which words a change overlaps. Each opaque inline token is its own span.
+ */
+export var segmentWordSpans = function segmentWordSpans(chars, span, locale) {
+  var segmenters = getSegmenters(locale);
+  var slice = chars.slice(span.from, span.to);
+  var _flattenChars3 = flattenChars(slice),
+    text = _flattenChars3.text,
+    indexMap = _flattenChars3.indexMap;
+  var spans = [];
+  if (segmenters) {
+    var _iterator4 = _createForOfIteratorHelper(segmenters.word.segment(text)),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var seg = _step4.value;
+        if (seg.isWordLike || seg.segment.includes(OBJECT_REPLACEMENT)) {
+          var from = span.from + stringIndexToOffset(indexMap, seg.index, 0);
+          var to = span.from + stringIndexToOffset(indexMap, seg.index + seg.segment.length, slice.length);
+          spans.push({
+            from: from,
+            to: to
+          });
+        }
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+    return spans;
+  }
+  var wordStart = -1;
+  for (var i = 0; i < slice.length; i++) {
+    var ch = slice[i];
+    if (ch === null) {
+      if (wordStart !== -1) {
+        spans.push({
+          from: span.from + wordStart,
+          to: span.from + i
+        });
+        wordStart = -1;
+      }
+      spans.push({
+        from: span.from + i,
+        to: span.from + i + 1
+      });
+    } else if (isWordChar(ch)) {
+      if (wordStart === -1) {
+        wordStart = i;
+      }
+    } else if (wordStart !== -1) {
+      spans.push({
+        from: span.from + wordStart,
+        to: span.from + i
+      });
+      wordStart = -1;
+    }
+  }
+  if (wordStart !== -1) {
+    spans.push({
+      from: span.from + wordStart,
+      to: span.from + slice.length
+    });
+  }
+  return spans;
+};

package/dist/esm/pm-plugins/calculateDiff/smart/thresholds.js

@@ -0,0 +1,39 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * Configurable thresholds for the `smart` diffType.
+ *
+ * See docs/smart-diff-design.md §3 and §6 for the exact semantics of each level.
+ */
+
+export var DEFAULT_SMART_THRESHOLDS = {
+  sentence: {
+    ratio: 0.4,
+    minChanged: 2
+  },
+  paragraph: {
+    ratio: 0.4,
+    minChanged: 2
+  },
+  node: {
+    ratio: 0.6,
+    textBearingRatio: 0.6
+  }
+};
+
+/**
+ * Merge caller overrides onto the defaults. Overrides are shallow-merged per level so a
+ * caller can tune a single field (e.g. only `sentence.ratio`) without re-specifying the
+ * rest.
+ */
+export var resolveThresholds = function resolveThresholds(overrides) {
+  if (!overrides) {
+    return DEFAULT_SMART_THRESHOLDS;
+  }
+  return {
+    sentence: _objectSpread(_objectSpread({}, DEFAULT_SMART_THRESHOLDS.sentence), overrides.sentence),
+    paragraph: _objectSpread(_objectSpread({}, DEFAULT_SMART_THRESHOLDS.paragraph), overrides.paragraph),
+    node: _objectSpread(_objectSpread({}, DEFAULT_SMART_THRESHOLDS.node), overrides.node)
+  };
+};

package/dist/esm/pm-plugins/decorations/createBlockChangedDecoration.js

@@ -1,7 +1,7 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import { convertToInlineCss } from '@atlaskit/editor-common/lazy-node-view';
 import { Decoration } from '@atlaskit/editor-prosemirror/view';
-import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+import { isExtendedEnabled } from '../isExtendedEnabled';
 import { standardDecorationMarkerVariable, deletedDecorationMarkerVariable, editingStyleQuoteNode, editingStyleRuleNode, editingStyleCardBlockNode, editingStyleNode, deletedContentStyleNew, deletedStyleQuoteNode, addedCellOverlayStyle, deletedCellOverlayStyle } from './colorSchemes/standard';
 import { traditionalDecorationMarkerVariableActive, traditionalDecorationMarkerVariableNew, traditionalDeletedDecorationMarkerVariableActive, traditionalDeletedDecorationMarkerVariableNew, traditionalStyleQuoteNodeActive, traditionalStyleQuoteNodeNew, traditionalStyleRuleNodeActive, traditionalStyleRuleNodeNew, traditionalStyleCardBlockNodeActive, traditionalStyleCardBlockNodeNew, traditionalStyleNodeActive, traditionalStyleNodeNew, getDeletedTraditionalInlineStyle, deletedTraditionalStyleQuoteNode, traditionalAddedCellOverlayStyle, deletedTraditionalCellOverlayStyle } from './colorSchemes/traditional';
 import { createBlockIndicatorAnchorWidgets } from './createAnchorDecorationWidgets';
@@ -23,7 +23,8 @@ var getBlockNodeStyle = function getBlockNodeStyle(_ref) {
     _ref$isInserted = _ref.isInserted,
     isInserted = _ref$isInserted === void 0 ? true : _ref$isInserted,
     _ref$isActive = _ref.isActive,
-    isActive = _ref$isActive === void 0 ? false : _ref$isActive;
+    isActive = _ref$isActive === void 0 ? false : _ref$isActive,
+    diffType = _ref.diffType;
   var isTraditional = colorScheme === 'traditional';
   if (['mediaSingle', 'mediaGroup', 'table',
   // Handle table separately to avoid border issues
@@ -36,13 +37,13 @@ var getBlockNodeStyle = function getBlockNodeStyle(_ref) {
   // Media nodes inside mediaSingle should not get position:relative
   // as it shifts the image outside its parent container (e.g. panel)
   if (nodeName === 'media') {
-    if (!isInserted && expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+    if (!isInserted && isExtendedEnabled(diffType)) {
       return isTraditional ? getDeletedTraditionalInlineStyle(false) : deletedDecorationMarkerVariable;
     }
     return isTraditional ? isActive ? traditionalStyleNodeActive : traditionalStyleNodeNew : editingStyleNode;
   }
   if (['tableCell', 'tableHeader'].includes(nodeName)) {
-    if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+    if (isExtendedEnabled(diffType)) {
       // This is used for positioning the cell overlay widget decorations
       return convertToInlineCss({
         position: 'relative'
@@ -52,13 +53,13 @@ var getBlockNodeStyle = function getBlockNodeStyle(_ref) {
     return undefined;
   }
   if (nodeName === 'panel') {
-    if (!isInserted && expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+    if (!isInserted && isExtendedEnabled(diffType)) {
       return isTraditional ? getDeletedTraditionalInlineStyle(false) : deletedDecorationMarkerVariable;
     }
     return isTraditional ? isActive ? traditionalStyleNodeActive : traditionalStyleNodeNew : editingStyleNode;
   }
   if (['extension', 'embedCard', 'listItem'].includes(nodeName)) {
-    if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+    if (isExtendedEnabled(diffType)) {
       if (isInserted) {
         return isTraditional && isActive ? traditionalDecorationMarkerVariableActive : isTraditional ? traditionalDecorationMarkerVariableNew : standardDecorationMarkerVariable;
       } else {
@@ -71,7 +72,7 @@ var getBlockNodeStyle = function getBlockNodeStyle(_ref) {
     return isTraditional && isActive ? traditionalDecorationMarkerVariableActive : isTraditional ? traditionalDecorationMarkerVariableNew : standardDecorationMarkerVariable;
   }
   if (nodeName === 'blockquote') {
-    if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+    if (isExtendedEnabled(diffType)) {
       if (isInserted) {
         return isTraditional ? isActive ? traditionalStyleQuoteNodeActive : traditionalStyleQuoteNodeNew : editingStyleQuoteNode;
       } else {
@@ -81,7 +82,7 @@ var getBlockNodeStyle = function getBlockNodeStyle(_ref) {
     return isTraditional ? isActive ? traditionalStyleQuoteNodeActive : traditionalStyleQuoteNodeNew : editingStyleQuoteNode;
   }
   if (nodeName === 'rule') {
-    if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+    if (isExtendedEnabled(diffType)) {
       if (isInserted) {
         return isTraditional ? isActive ? traditionalStyleRuleNodeActive : traditionalStyleRuleNodeNew : editingStyleRuleNode;
       } else {
@@ -91,7 +92,7 @@ var getBlockNodeStyle = function getBlockNodeStyle(_ref) {
     return isTraditional ? isActive ? traditionalStyleRuleNodeActive : traditionalStyleRuleNodeNew : editingStyleRuleNode;
   }
   if (nodeName === 'blockCard') {
-    if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+    if (isExtendedEnabled(diffType)) {
       if (isInserted) {
         return isTraditional ? isActive ? traditionalStyleCardBlockNodeActive : traditionalStyleCardBlockNodeNew : editingStyleCardBlockNode;
       } else {
@@ -100,7 +101,7 @@ var getBlockNodeStyle = function getBlockNodeStyle(_ref) {
     }
     return isTraditional ? isActive ? traditionalStyleCardBlockNodeActive : traditionalStyleCardBlockNodeNew : editingStyleCardBlockNode;
   }
-  if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+  if (isExtendedEnabled(diffType)) {
     if (isInserted) {
       return isTraditional ? isActive ? traditionalStyleNodeActive : traditionalStyleNodeNew : editingStyleNode;
     } else {
@@ -129,7 +130,8 @@ export var createBlockChangedDecoration = function createBlockChangedDecoration(
     shouldHideDeleted = _ref2$shouldHideDelet === void 0 ? false : _ref2$shouldHideDelet,
     _ref2$showIndicators = _ref2.showIndicators,
     showIndicators = _ref2$showIndicators === void 0 ? false : _ref2$showIndicators,
-    doc = _ref2.doc;
+    doc = _ref2.doc,
+    diffType = _ref2.diffType;
   var decorations = [];
   var diffId = crypto.randomUUID();
   if (shouldHideDeleted) {
@@ -139,11 +141,12 @@ export var createBlockChangedDecoration = function createBlockChangedDecoration(
       decorationType: 'block',
       diffId: diffId,
       isActive: isActive,
-      nodeName: change.name
+      nodeName: change.name,
+      diffType: diffType
     }))];
   }
   var style;
-  if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true) && ['tableCell', 'tableHeader'].includes(change.name)) {
+  if (isExtendedEnabled(diffType) && ['tableCell', 'tableHeader'].includes(change.name)) {
     var cellOverlay = document.createElement('div');
     var cellOverlayStyle = isInserted ? colorScheme === 'traditional' ? traditionalAddedCellOverlayStyle : addedCellOverlayStyle : colorScheme === 'traditional' ? deletedTraditionalCellOverlayStyle : deletedCellOverlayStyle;
     cellOverlay.setAttribute('style', cellOverlayStyle);
@@ -155,18 +158,20 @@ export var createBlockChangedDecoration = function createBlockChangedDecoration(
       key: 'cell-overlay-decoration'
     }));
   }
-  if (expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+  if (isExtendedEnabled(diffType)) {
     style = getBlockNodeStyle({
       nodeName: change.name,
       colorScheme: colorScheme,
       isInserted: isInserted,
-      isActive: isActive
+      isActive: isActive,
+      diffType: diffType
     });
   } else {
     style = getBlockNodeStyle({
       nodeName: change.name,
       colorScheme: colorScheme,
-      isActive: isActive
+      isActive: isActive,
+      diffType: diffType
     });
   }
   var className = getNodeClass(change.name);
@@ -179,10 +184,11 @@ export var createBlockChangedDecoration = function createBlockChangedDecoration(
       decorationType: 'block',
       diffId: diffId,
       isActive: isActive,
-      nodeName: change.name
+      nodeName: change.name,
+      diffType: diffType
     })));
   }
-  if (decorations.length > 0 && showIndicators && doc && expValEquals('platform_editor_diff_plugin_extended', 'isEnabled', true)) {
+  if (decorations.length > 0 && showIndicators && doc && isExtendedEnabled(diffType)) {
     decorations.push.apply(decorations, _toConsumableArray(createBlockIndicatorAnchorWidgets({
       doc: doc,
       from: change.from,