@seafile/seafile-editor 0.3.76

package/dist/utils/diff/diff.js

@@ -0,0 +1,855 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import lodash from 'lodash';
+import { compareTwoStrings } from './compare-strings';
+import { Node, Text } from 'slate';
+import { deserialize } from '../slate2markdown';
+
+function equalityFunctionForSlate(a, b) {
+  if (a.type !== b.type) {
+    return false;
+  }
+
+  if (lodash.isEqual(a, b)) {
+    return true;
+  }
+
+  if (Text.isText(a) && Text.isText(b)) {
+    if (compareTwoStrings(a.text, b.text) >= 0.5) {
+      return 'changed';
+    } else {
+      return false;
+    }
+  }
+
+  if (a.type === b.type && (a.type.includes('ordered_list') || a.type.includes('unordered_list'))) {
+    if (compareTwoStrings(Node.text(a), Node.text(b)) >= 0.5) {
+      return 'changed';
+    }
+  }
+
+  if (a.type === b.type && (a.children.length > 1 || b.children.length > 1) && a.type === 'list_item') {
+    if (compareTwoStrings(Node.text(a), Node.text(b)) >= 0.5) {
+      return 'changed';
+    }
+  }
+
+  if (a.type === b.type && a.type === 'paragraph') {
+    if (compareTwoStrings(Node.text(a), Node.text(b)) >= 0.5) {
+      return 'changed';
+    }
+  }
+
+  if (a.type === b.type && a.type === 'table') {
+    if (compareTwoStrings(Node.text(a), Node.text(b)) >= 0.5) {
+      return 'changed';
+    }
+  }
+  /*
+   * the table diff is not the same as list diff,
+   * in the table, if the old table_line and the new table_line or the old table_cell and new table_cell are not equal
+   * the table_line or table_cells is set as changed, then the diff is expressed in the text of table_cell
+   * */
+
+
+  if (a.type === b.type && a.type === 'table_row') {
+    return 'changed';
+  }
+
+  if (a.type === b.type && a.type === 'table_cell') {
+    return 'changed';
+  }
+
+  return false;
+}
+
+function defaultEqualityFunction(a, b) {
+  return a === b;
+}
+
+var SlateDiff = /*#__PURE__*/function () {
+  function SlateDiff() {
+    var _this = this;
+
+    _classCallCheck(this, SlateDiff);
+
+    this.deepDiff = function (newNodes, oldNodes, equalFunc) {
+      var depth = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+      var slateDiffNodes = []; // remeber current nodes depth
+
+      var nodeDepth = depth + 1;
+      var diff = new Diff({
+        equalFunc: equalFunc
+      });
+      diff.ArrayDiff(newNodes, oldNodes);
+
+      for (var i = 0; i < diff.diff.length; i++) {
+        var diffElement = diff.diff[i];
+        var changeType = diffElement.changeType;
+
+        if (changeType === 'common') {
+          var newItemData = {
+            diff_state: 'diff-common',
+            new_index: diffElement.newIndex,
+            old_index: -1,
+            node_depth: nodeDepth
+          };
+          diffElement.item.data = Object.assign(diffElement.item.data ? diffElement.item.data : {}, newItemData);
+        } else if (changeType === 'added') {
+          if (Text.isText(diffElement.item)) {
+            diffElement.item.ADD = true;
+          } else {
+            var _newItemData = {
+              diff_state: 'diff-added',
+              new_index: diffElement.newIndex,
+              old_index: -1,
+              node_depth: nodeDepth
+            };
+            diffElement.item.data = Object.assign(diffElement.item.data ? diffElement.item.data : {}, _newItemData);
+          }
+        } else if (changeType === 'removed') {
+          if (Text.isText(diffElement.item)) {
+            diffElement.item.DELETE = true;
+          } else {
+            var _newItemData2 = {
+              diff_state: 'diff-removed',
+              new_index: -1,
+              old_index: diffElement.oldIndex,
+              node_depth: nodeDepth
+            };
+            diffElement.item.data = Object.assign(diffElement.item.data ? diffElement.item.data : {}, _newItemData2);
+          }
+        } else if (changeType === 'replaced') {
+          var diffNodes = void 0,
+              elementType = diffElement.item.type || 'text';
+
+          if (elementType === 'text') {
+            // compare text diff leaves use getTextDiff function
+            diffNodes = _this.getTextDiff(diffElement.newItem, diffElement.oldItem);
+          } else if (elementType.includes('ordered_list') || elementType.includes('unordered_list') || elementType.includes('list_item')) {
+            diffNodes = _this.deepDiff(diffElement.newItem.children, diffElement.oldItem.children, equalFunc, nodeDepth);
+          } else if (elementType === 'table' || elementType === 'table_row' || elementType === 'table_cell') {
+            diffNodes = _this.deepDiff(diffElement.newItem.children, diffElement.oldItem.children, equalFunc, nodeDepth);
+          } else if (elementType === 'paragraph') {
+            // compare text or inline
+            diffNodes = _this.deepDiff(diffElement.newItem.children, diffElement.oldItem.children, equalFunc, nodeDepth);
+          }
+
+          if (Text.isText(diffElement.item)) {
+            diffElement.item = diffNodes;
+          } else {
+            var _newItemData3 = {
+              diff_state: 'diff-replaced',
+              new_index: -1,
+              old_index: diffElement.oldIndex,
+              node_depth: nodeDepth
+            };
+            diffElement.item.data = Object.assign(diffElement.item.data ? diffElement.item.data : {}, _newItemData3);
+            diffElement.item.children = diffNodes;
+          }
+        } // add diff nodes to document
+
+
+        if (Array.isArray(diffElement.item)) {
+          slateDiffNodes = slateDiffNodes.concat(diffElement.item);
+        } else {
+          slateDiffNodes.push(diffElement.item);
+        }
+      }
+
+      return slateDiffNodes;
+    };
+
+    this.getDiffDocument = function (newMarkdownContent, oldMarkdownContent) {
+      var newNodes = deserialize(newMarkdownContent);
+      var oldNodes = deserialize(oldMarkdownContent);
+
+      var topSlateDiffNodes = _this.deepDiff(newNodes, oldNodes, equalityFunctionForSlate); //handle replaced paragraph
+
+
+      topSlateDiffNodes = _this.splitTopDiffNodes(topSlateDiffNodes);
+      return topSlateDiffNodes;
+    };
+  }
+
+  _createClass(SlateDiff, [{
+    key: "getTextDiff",
+    value: function getTextDiff(newTextItem, oldTextItem) {
+      var textNodes = [];
+      var nodes = this.textDiff(newTextItem.text, oldTextItem.text);
+      textNodes = textNodes.concat(nodes);
+      return textNodes;
+    }
+  }, {
+    key: "textDiff",
+    value: function textDiff(newText, oldText) {
+      var marks = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+      var texts = [];
+      var diff = new Diff({
+        equalFunc: defaultEqualityFunction
+      });
+      diff.StringDiff(newText, oldText);
+      var textDiffArray = diff.diff;
+      var stringFragment = '';
+      var lastDiffState = textDiffArray[0].changeType;
+      textDiffArray.forEach(function (textCharacter, index, textDiffArray) {
+        var markType = '';
+
+        if (lastDiffState === 'removed') {
+          markType = 'DELETE';
+        } else if (lastDiffState === 'added') {
+          markType = 'ADD';
+        }
+
+        if (lastDiffState === textCharacter.changeType) {
+          stringFragment += textCharacter.item;
+
+          if (index === textDiffArray.length - 1) {
+            texts.push(_objectSpread(_defineProperty({
+              text: stringFragment
+            }, markType, true), marks));
+          }
+        } else if (textCharacter.changeType !== lastDiffState) {
+          texts.push(_objectSpread(_objectSpread({
+            text: stringFragment
+          }, marks), {}, _defineProperty({}, markType, true)));
+          lastDiffState = textCharacter.changeType;
+          stringFragment = textCharacter.item;
+
+          if (index === textDiffArray.length - 1) {
+            if (lastDiffState === 'removed') {
+              markType = 'DELETE';
+            } else if (lastDiffState === 'added') {
+              markType = 'ADD';
+            }
+
+            texts.push(_objectSpread(_defineProperty({
+              text: stringFragment
+            }, markType, true), marks));
+          }
+        }
+      });
+      return texts;
+    }
+  }, {
+    key: "splitDiffParagraph",
+    value: function splitDiffParagraph(diffParagraph) {
+      // clone the replace paragraph to wrap the deleted and added nodes
+      var newParagraph = lodash.cloneDeep(diffParagraph),
+          oldParagraph = lodash.cloneDeep(diffParagraph),
+          // wrap new paragraph nodes and old paragraph nodes
+      newParagraphNodes = [],
+          oldParagraphNodes = []; // traverse paragraph nodes
+
+      diffParagraph.children.forEach(function (node, index1, nodes) {
+        if (node.type === 'link' || node.type === 'image') {
+          // if the node is inline node, like link
+          // if the inline is added
+          if (node.data.diff_state === 'diff-added') {
+            // push the inline node to new paragraph nodes
+            newParagraphNodes.push(node);
+          } else if (node.data.diff_state === 'diff-removed') {
+            // if the inline is added push the inline node to new paragraph nodes
+            oldParagraphNodes.push(node);
+          } else {
+            // if the inline node is common new paragraph node and old paragraph all push the inline node
+            newParagraphNodes.push(node);
+            oldParagraphNodes.push(node);
+          }
+        } else {
+          if (node.ADD) {
+            newParagraphNodes.push(node);
+          } else if (node.DELETE) {
+            oldParagraphNodes.push(node);
+          } else {
+            // push common text
+            newParagraphNodes.push(node);
+            oldParagraphNodes.push(node);
+          }
+        }
+      }); // set new paragraph and old paragraph nodes
+
+      newParagraph.children = newParagraphNodes;
+      oldParagraph.data.paragraph_state = 'old-paragraph';
+      newParagraph.data.paragraph_state = 'new-paragraph';
+      oldParagraph.children = oldParagraphNodes;
+      return [oldParagraph, newParagraph];
+    }
+  }, {
+    key: "splitTopDiffNodes",
+    value: function splitTopDiffNodes(slateDiffNodes) {
+      var _this2 = this;
+
+      // newSlateDiffNodes used to wrap the new slate nodes
+      var newSlateDiffNodes = []; // traverse slate top Nodes and find the paragraph handle it
+
+      slateDiffNodes.forEach(function (node) {
+        if (node.data.diff_state === 'diff-replaced' && node.type === 'paragraph') {
+          var splicedParagraph = _this2.splitDiffParagraph(node); // push the old and new paragraph node to newSlateDiffNodes
+
+
+          newSlateDiffNodes.push(splicedParagraph[0], splicedParagraph[1]);
+        } else if (node.data.diff_state === 'diff-replaced' && node.type === 'table') {
+          _this2.splitTableDiffParagraph(node);
+
+          newSlateDiffNodes.push(node);
+        } else {
+          newSlateDiffNodes.push(node);
+        }
+      });
+      return newSlateDiffNodes;
+    }
+  }, {
+    key: "splitTableDiffParagraph",
+    value: function splitTableDiffParagraph(node) {
+      var _this3 = this;
+
+      node.children.forEach(function (tableRow, rowIndex, tablerows) {
+        if (tableRow.data.diff_state === 'diff-replaced') {
+          tableRow.children.forEach(function (tableCell) {
+            if (tableCell.data.diff_state === 'diff-replaced') {
+              if (tableCell.children[0].data.diff_state === 'diff-replaced') {
+                var splicedParagraphNodes = _this3.splitDiffParagraph(tableCell.children[0]);
+
+                tableCell.children = splicedParagraphNodes;
+              }
+            }
+          });
+        }
+      });
+      return node;
+    }
+  }]);
+
+  return SlateDiff;
+}();
+
+var ArrayDiffElement = /*#__PURE__*/function () {
+  function ArrayDiffElement(item, newIndex, oldIndex) {
+    _classCallCheck(this, ArrayDiffElement);
+
+    this.item = item;
+    this.newIndex = newIndex;
+    this.oldIndex = oldIndex;
+  }
+
+  _createClass(ArrayDiffElement, [{
+    key: "added",
+    value: function added() {
+      return this.oldIndex === undefined;
+    }
+  }, {
+    key: "removed",
+    value: function removed() {
+      return this.newIndex === undefined;
+    }
+  }, {
+    key: "common",
+    value: function common() {
+      return this.oldIndex !== undefined && this.newIndex !== undefined;
+    }
+  }]);
+
+  return ArrayDiffElement;
+}();
+
+var Diff = /*#__PURE__*/function () {
+  function Diff(opts) {
+    _classCallCheck(this, Diff);
+
+    this.equalFunc = opts.equalFunc ? opts.equalFunc : defaultEqualityFunction;
+    if (opts.shouldDetectChange != undefined) this.shouldDetectChange = opts.shouldDetectChange;else this.shouldDetectChange = false;
+    this.similarityFunc = opts.similarityFunc;
+  }
+  /**
+   Appends an array item to the subsequence of items that were added in the new array.
+   @method  added
+   @param   item   The array item that was added.
+   **/
+
+
+  _createClass(Diff, [{
+    key: "addAdded",
+    value: function addAdded(item, newIndex) {
+      var element = new ArrayDiffElement(item, newIndex, undefined);
+      element.changeType = 'added';
+      this.added.push(element);
+      this.diff.push(element);
+    }
+    /**
+     Appends an array item to the subsequence of items that were removed from the old array.
+     @method  removed
+     @param   item     The array item that was added.
+     **/
+
+  }, {
+    key: "addRemoved",
+    value: function addRemoved(item, oldIndex) {
+      var element = new ArrayDiffElement(item, undefined, oldIndex);
+      this.removed.push(element);
+      element.changeType = 'removed';
+      this.diff.push(element);
+    }
+  }, {
+    key: "addReplaced",
+    value: function addReplaced(oldItem, newItem, oldIndex, newIndex) {
+      var element = new ArrayDiffElement(oldItem, newIndex, oldIndex);
+      element.newItem = newItem;
+      element.oldItem = oldItem;
+      element.changeType = 'replaced';
+      this.replaced.push(element);
+      this.diff.push(element);
+    }
+    /**
+     Appends an array item to the longest common subsequence between the new and old arrays.
+     @method  common
+     @param   item    The array item that was added.
+     **/
+
+  }, {
+    key: "addCommon",
+    value: function addCommon(oldItem, newItem, oldIndex, newIndex) {
+      var element = new ArrayDiffElement(oldItem, newIndex, oldIndex);
+      element.newItem = newItem;
+      element.changeType = 'common';
+      element.oldItem = oldItem;
+      this.common.push(element);
+      this.diff.push(element);
+    }
+  }, {
+    key: "StringDiff",
+    value: function StringDiff(newString, oldString) {
+      var newLength = newString.length;
+      var oldLength = oldString.length;
+      var n = 0;
+      var o = 0;
+      var table = [];
+      table[newLength] = [];
+
+      for (o = oldLength; o >= 0; table[newLength][o--] = 0) {
+        ;
+      }
+
+      for (n = newLength - 1; n >= 0; n--) {
+        table[n] = [];
+        table[n][oldLength] = 0;
+
+        for (o = oldLength - 1; o >= 0; o--) {
+          if (this.equalFunc(newString[n], oldString[o])) {
+            table[n][o] = table[n + 1][o + 1] + 1;
+          } else {
+            table[n][o] = Math.max(table[n + 1][o], table[n][o + 1]);
+          }
+        }
+      } // Fill in the subsequence arrays
+
+
+      this.common = [];
+      this.added = [];
+      this.removed = [];
+      this.replaced = [];
+      this.diff = [];
+      n = o = 0;
+
+      while (n < newLength && o < oldLength) {
+        var diffState = this.equalFunc(newString[n], oldString[o]);
+
+        if (diffState) {
+          var newItem = newString[n];
+          var oldItem = oldString[o];
+          this.addCommon(oldItem, newItem, o, n);
+          n++;
+          o++;
+        } else if (table[n + 1][o] >= table[n][o + 1]) {
+          this.addAdded(newString[n], n);
+          n++;
+        } else {
+          this.addRemoved(oldString[o], o);
+          o++;
+        }
+      }
+
+      for (; n < newLength; n++) {
+        this.addAdded(newString[n], n);
+      }
+
+      for (; o < oldLength; o++) {
+        this.addRemoved(oldString[o], o);
+      }
+    }
+  }, {
+    key: "ArrayDiff",
+    value: function ArrayDiff(newArray, oldArray, callback) {
+      //newArray = newArray.toArray();
+      //oldArray = oldArray.toArray();
+      var newLength = newArray.length;
+      var oldLength = oldArray.length;
+      var n = 0;
+      var o = 0;
+      var table = []; // Build out the table
+
+      table[newLength] = [];
+
+      for (o = oldLength; o >= 0; table[newLength][o--] = 0) {
+        ;
+      }
+
+      for (n = newLength - 1; n >= 0; n--) {
+        table[n] = [];
+        table[n][oldLength] = 0;
+
+        for (o = oldLength - 1; o >= 0; o--) {
+          if (this.equalFunc(newArray[n], oldArray[o])) {
+            table[n][o] = table[n + 1][o + 1] + 1;
+          } else {
+            table[n][o] = Math.max(table[n + 1][o], table[n][o + 1]);
+          }
+        }
+      } // Fill in the subsequence arrays
+
+
+      this.common = [];
+      this.added = [];
+      this.removed = [];
+      this.replaced = [];
+      this.diff = [];
+      n = o = 0;
+
+      while (n < newLength && o < oldLength) {
+        var diffState = this.equalFunc(newArray[n], oldArray[o]);
+
+        if (diffState) {
+          var newItem = newArray[n];
+          var oldItem = oldArray[o];
+
+          if (diffState === 'changed') {
+            this.addReplaced(oldItem, newItem, o, n);
+          } else {
+            //if (newItem.isVoid) {
+            this.addCommon(oldItem, newItem, o, n);
+          }
+
+          if (callback) {
+            callback('C', o, n);
+          }
+
+          n++;
+          o++;
+        } else if (table[n + 1][o] >= table[n][o + 1]) {
+          this.addAdded(newArray[n], n);
+
+          if (callback) {
+            callback('A', 0, n);
+          }
+
+          n++;
+        } else {
+          this.addRemoved(oldArray[o], o);
+
+          if (callback) {
+            callback('D', o, 0);
+          }
+
+          o++;
+        }
+      }
+
+      for (; n < newLength; n++) {
+        this.addAdded(newArray[n], n);
+
+        if (callback) {
+          callback('A', 0, n);
+        }
+      }
+
+      for (; o < oldLength; o++) {
+        this.addRemoved(oldArray[o], o);
+
+        if (callback) {
+          callback('D', o, 0);
+        }
+      }
+    }
+  }]);
+
+  return Diff;
+}();
+
+var Diff3 = /*#__PURE__*/function () {
+  function Diff3(opts) {
+    _classCallCheck(this, Diff3);
+
+    opts = opts || {};
+    this.equalFunc = opts.equalFunc ? opts.equalFunc : defaultEqualityFunction;
+    if (opts.shouldDetectChange != undefined) this.shouldDetectChange = opts.shouldDetectChange;else this.shouldDetectChange = false;
+    this.similarityFunc = opts.similarityFunc;
+    this.chunks = [];
+    this.common = [];
+    this.added = [];
+    this.removed = [];
+    this.mergedArray = [];
+  }
+
+  _createClass(Diff3, [{
+    key: "diff3",
+    value: function diff3(oArray, aArray, bArray) {
+      this.oArray = oArray;
+      this.aArray = aArray;
+      this.bArray = bArray;
+      var oaDiff = new Diff({
+        equalFunc: this.equalFunc,
+        shouldDetectChange: this.shouldDetectChange,
+        similarityFunc: this.similarityFunc
+      });
+      oaDiff.ArrayDiff(aArray, oArray);
+      var obDiff = new Diff({
+        equalFunc: this.equalFunc,
+        shouldDetectChange: this.shouldDetectChange,
+        similarityFunc: this.similarityFunc
+      });
+      obDiff.ArrayDiff(bArray, oArray);
+      var M_oa = [];
+
+      for (var i = 0; i < oArray.length; i++) {
+        M_oa[i] = [];
+
+        for (var j = 0; j < aArray.length; j++) {
+          M_oa[i][j] = 0;
+        }
+      }
+
+      var _iterator = _createForOfIteratorHelper(oaDiff.common),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var item = _step.value;
+          M_oa[item.oldIndex][item.newIndex] = 1;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      this.M_oa = M_oa;
+      var M_ob = [];
+
+      for (var _i = 0; _i < oArray.length; _i++) {
+        M_ob[_i] = [];
+
+        for (var _j = 0; _j < bArray.length; _j++) {
+          M_ob[_i][_j] = 0;
+        }
+      }
+
+      var _iterator2 = _createForOfIteratorHelper(obDiff.common),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _item = _step2.value;
+          M_ob[_item.oldIndex][_item.newIndex] = 1;
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+
+      this.M_ob = M_ob;
+      /*
+      console.log("M_oa");
+      console.log(M_oa);
+      console.log("M_ob");
+      console.log(M_ob);
+      */
+
+      var lo = 0;
+      var la = 0;
+      var lb = 0;
+      var finalStable = undefined; // while (true) {
+      //   // find i that the cursor at the three array not match
+      //   let i = 0;
+      //   var iFound = false;
+      //   while (true) {
+      //     if (M_oa[lo+i][la+i] == 0 || M_ob[lo+i][lb+i] == 0) {
+      //       iFound = true;
+      //       break;
+      //     }
+      //     i++;
+      //     if (lo+i == oArray.length || la+i == aArray.length ||
+      //       lb+i == bArray.length)
+      //       break;
+      //   }
+      //   if (iFound == false) {
+      //     // go out and output a final stable chunk
+      //     //console.log("iFound == false");
+      //     finalStable = true;
+      //     break;
+      //   }
+      //
+      //   if (i > 0) {
+      //     //console.log("stable chunk ");
+      //     var chunk = {};
+      //     chunk.startO = lo;
+      //     chunk.startA = la;
+      //     chunk.startB = lb;
+      //     chunk.endO = lo+i-1;
+      //     chunk.endA = la+i-1;
+      //     chunk.endB = lb+i-1;
+      //     chunk.isStable = true;
+      //     this.chunks.push(chunk);
+      //     //printChunk(oArray, aArray, bArray, chunk);
+      //     lo = lo + i;
+      //     la = la + i;
+      //     lb = lb + i;
+      //     continue;
+      //   }
+      //
+      //   //console.log("unstable chunk ");
+      //   let o;
+      //   let a;
+      //   let b;
+      //   let found = false;
+      //   for (o = lo; o < oArray.length; o++) {
+      //     for (a = la; a < aArray.length; a++) {
+      //       if (M_oa[o][a] != true) {
+      //         continue;
+      //       }
+      //
+      //       for (b = lb; b < bArray.length; b++) {
+      //         if (M_ob[o][b] == true) {
+      //           found = true;
+      //           break;
+      //         }
+      //       }
+      //       if (found == true) {
+      //         break;
+      //       }
+      //     }
+      //     if (found == true) {
+      //       break;
+      //     }
+      //   }
+      //
+      //   if (found == true) {
+      //     let chunk = {}
+      //     chunk.startO = lo;
+      //     chunk.startA = la;
+      //     chunk.startB = lb;
+      //     chunk.endO = o-1;
+      //     chunk.endA = a-1;
+      //     chunk.endB = b-1;
+      //     chunk.isStable = false;
+      //     this.chunks.push(chunk);
+      //     //printChunk(oArray, aArray, bArray, chunk);
+      //     lo = o;
+      //     la = a;
+      //     lb = b;
+      //     continue;
+      //   } else {
+      //     // output a final unstable chunk
+      //     finalStable = false;
+      //     break;
+      //   }
+      // }
+      // output the final chunk
+
+      if (lo < oArray.length || la < aArray.length || lb < bArray.length) {
+        //console.log("final chunk ");
+        var chunk = {};
+        chunk.startO = lo;
+        chunk.endO = oArray.length - 1;
+        chunk.startA = la;
+        chunk.endA = aArray.length - 1;
+        chunk.startB = lb;
+        chunk.endB = bArray.length - 1;
+        chunk.isStable = finalStable;
+        this.chunks.push(chunk); //printChunk(oArray, aArray, bArray, chunk);
+      }
+    }
+  }, {
+    key: "calPatchChunk",
+    value: function calPatchChunk(chunk) {
+      for (var i = chunk.startA; i <= chunk.endA; ++i) {
+        // find if item also in O
+        var found = false;
+
+        for (var j = chunk.startO; j <= chunk.endO; ++j) {
+          if (this.M_oa[j][i] === 1) {
+            // The item in both A and O
+            // The item is removed by B
+            found = true;
+            break;
+          }
+        }
+
+        if (found === false) {
+          // the item not found in O
+          // the item is added or modifed in A
+          // keep
+          this.mergedArray.push(this.aArray[i]);
+        }
+      }
+
+      for (var _i2 = chunk.startB; _i2 <= chunk.endB; ++_i2) {
+        // find if item also in O
+        var found = false;
+
+        for (var _j2 = chunk.startO; _j2 <= chunk.endO; ++_j2) {
+          if (this.M_ob[_j2][_i2] === 1) {
+            // The item in both B and O
+            // the item is removed by A (or moved by A)
+            // do nothing
+            found = true;
+            break;
+          }
+        }
+
+        if (found) continue; // the matched item not found in O
+        // the item is added or modifed in B
+
+        this.mergedArray.push(this.bArray[_i2]);
+      }
+    }
+  }, {
+    key: "calPatch",
+    value: function calPatch() {
+      var _iterator3 = _createForOfIteratorHelper(this.chunks),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var chunk = _step3.value;
+
+          if (chunk.isStable) {
+            for (var i = 0; i + chunk.startA <= chunk.endA; ++i) {
+              var c = {};
+              c.indexA = i + chunk.startA;
+              c.indexO = i + chunk.startO;
+              c.indexB = i + chunk.startB; //this.common.push(c);
+
+              this.mergedArray.push(this.aArray[c.indexA]);
+            }
+          }
+
+          if (!chunk.isStable) {
+            this.calPatchChunk(chunk);
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+  }]);
+
+  return Diff3;
+}();
+
+export { Diff, Diff3, equalityFunctionForSlate, SlateDiff };