@commercetools/sync-actions 6.1.1 → 7.0.0-rc.1

package/dist/sync-actions.es.js

@@ -1,7 +1,6 @@
 import flatten from 'lodash.flatten';
 import isEqual from 'lodash.isequal';
 import isNil from 'lodash.isnil';
-import { DiffPatcher } from 'jsondiffpatch/dist/jsondiffpatch.cjs';
 import forEach from 'lodash.foreach';
 import uniqWith from 'lodash.uniqwith';
 import intersection from 'lodash.intersection';
@@ -19,14 +18,69 @@ function _arrayWithHoles(r) {
 function _arrayWithoutHoles(r) {
   if (Array.isArray(r)) return _arrayLikeToArray(r);
 }
+function _assertThisInitialized(e) {
+  if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+function _callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
+    writable: false
+  }), e;
+}
 function _defineProperty(e, r, t) {
   return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
     value: t,
-    enumerable: !0,
-    configurable: !0,
-    writable: !0
+    enumerable: true,
+    configurable: true,
+    writable: true
   }) : e[r] = t, e;
 }
+function _get() {
+  return _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function (e, t, r) {
+    var p = _superPropBase(e, t);
+    if (p) {
+      var n = Object.getOwnPropertyDescriptor(p, t);
+      return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value;
+    }
+  }, _get.apply(null, arguments);
+}
+function _getPrototypeOf(t) {
+  return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+    return t.__proto__ || Object.getPrototypeOf(t);
+  }, _getPrototypeOf(t);
+}
+function _inherits(t, e) {
+  if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+  t.prototype = Object.create(e && e.prototype, {
+    constructor: {
+      value: t,
+      writable: true,
+      configurable: true
+    }
+  }), Object.defineProperty(t, "prototype", {
+    writable: false
+  }), e && _setPrototypeOf(t, e);
+}
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function () {
+    return !!t;
+  })();
+}
 function _iterableToArray(r) {
   if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
 }
@@ -38,15 +92,15 @@ function _iterableToArrayLimit(r, l) {
       i,
       u,
       a = [],
-      f = !0,
-      o = !1;
+      f = true,
+      o = false;
     try {
       if (i = (t = t.call(r)).next, 0 === l) {
         if (Object(t) !== t) return;
         f = !1;
       } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
     } catch (r) {
-      o = !0, n = r;
+      o = true, n = r;
     } finally {
       try {
         if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
@@ -76,7 +130,7 @@ function ownKeys(e, r) {
 function _objectSpread2(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) {
+    r % 2 ? ownKeys(Object(t), true).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));
@@ -90,8 +144,8 @@ function _objectWithoutProperties(e, t) {
     r,
     i = _objectWithoutPropertiesLoose(e, t);
   if (Object.getOwnPropertySymbols) {
-    var s = Object.getOwnPropertySymbols(e);
-    for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
   }
   return i;
 }
@@ -99,14 +153,34 @@ function _objectWithoutPropertiesLoose(r, e) {
   if (null == r) return {};
   var t = {};
   for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
-    if (e.includes(n)) continue;
+    if (-1 !== e.indexOf(n)) continue;
     t[n] = r[n];
   }
   return t;
 }
+function _possibleConstructorReturn(t, e) {
+  if (e && ("object" == typeof e || "function" == typeof e)) return e;
+  if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
+  return _assertThisInitialized(t);
+}
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
+}
 function _slicedToArray(r, e) {
   return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
 }
+function _superPropBase(t, o) {
+  for (; !{}.hasOwnProperty.call(t, o) && null !== (t = _getPrototypeOf(t)););
+  return t;
+}
+function _superPropGet(t, o, e, r) {
+  var p = _get(_getPrototypeOf(t.prototype ), o, e);
+  return 2 & r && "function" == typeof p ? function (t) {
+    return p.apply(e, t);
+  } : p;
+}
 function _toConsumableArray(r) {
   return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
 }
@@ -114,11 +188,11 @@ function _toPrimitive(t, r) {
   if ("object" != typeof t || !t) return t;
   var e = t[Symbol.toPrimitive];
   if (void 0 !== e) {
-    var i = e.call(t, r || "default");
+    var i = e.call(t, r);
     if ("object" != typeof i) return i;
     throw new TypeError("@@toPrimitive must return a primitive value.");
   }
-  return ("string" === r ? String : Number)(t);
+  return (String )(t);
 }
 function _toPropertyKey(t) {
   var i = _toPrimitive(t, "string");
@@ -232,6 +306,1206 @@ function createMapActionGroup() {
   };
 }
 
+var Processor = /*#__PURE__*/function () {
+  function Processor(options) {
+    _classCallCheck(this, Processor);
+    this.selfOptions = options || {};
+    this.pipes = {};
+  }
+  return _createClass(Processor, [{
+    key: "options",
+    value: function options(_options) {
+      if (_options) {
+        this.selfOptions = _options;
+      }
+      return this.selfOptions;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  }, {
+    key: "pipe",
+    value: function pipe(name, pipeArg) {
+      var pipe = pipeArg;
+      if (typeof name === 'string') {
+        if (typeof pipe === 'undefined') {
+          return this.pipes[name];
+        } else {
+          this.pipes[name] = pipe;
+        }
+      }
+      if (name && name.name) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        pipe = name;
+        if (pipe.processor === this) {
+          return pipe;
+        }
+        this.pipes[pipe.name] = pipe;
+      }
+      pipe.processor = this;
+      return pipe;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  }, {
+    key: "process",
+    value: function process(input, pipe) {
+      var context = input;
+      context.options = this.options();
+      var nextPipe = pipe || input.pipe || 'default';
+      var lastPipe;
+      while (nextPipe) {
+        if (typeof context.nextAfterChildren !== 'undefined') {
+          // children processed and coming back to parent
+          context.next = context.nextAfterChildren;
+          context.nextAfterChildren = null;
+        }
+        if (typeof nextPipe === 'string') {
+          nextPipe = this.pipe(nextPipe);
+        }
+        nextPipe.process(context);
+        lastPipe = nextPipe;
+        nextPipe = null;
+        if (context) {
+          if (context.next) {
+            context = context.next;
+            nextPipe = context.pipe || lastPipe;
+          }
+        }
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      return context.hasResult ? context.result : undefined;
+    }
+  }]);
+}();
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+var Pipe = /*#__PURE__*/function () {
+  function Pipe(name) {
+    _classCallCheck(this, Pipe);
+    this.name = name;
+    this.filters = [];
+  }
+  return _createClass(Pipe, [{
+    key: "process",
+    value: function process(input) {
+      if (!this.processor) {
+        throw new Error('add this pipe to a processor before using it');
+      }
+      var debug = this.debug;
+      var length = this.filters.length;
+      var context = input;
+      for (var index = 0; index < length; index++) {
+        var filter = this.filters[index];
+        if (debug) {
+          this.log("filter: ".concat(filter.filterName));
+        }
+        filter(context);
+        if (_typeof(context) === 'object' && context.exiting) {
+          context.exiting = false;
+          break;
+        }
+      }
+      if (!context.next && this.resultCheck) {
+        this.resultCheck(context);
+      }
+    }
+  }, {
+    key: "log",
+    value: function log(msg) {
+      console.log("[jsondiffpatch] ".concat(this.name, " pipe, ").concat(msg));
+    }
+  }, {
+    key: "append",
+    value: function append() {
+      var _this$filters;
+      (_this$filters = this.filters).push.apply(_this$filters, arguments);
+      return this;
+    }
+  }, {
+    key: "prepend",
+    value: function prepend() {
+      var _this$filters2;
+      (_this$filters2 = this.filters).unshift.apply(_this$filters2, arguments);
+      return this;
+    }
+  }, {
+    key: "indexOf",
+    value: function indexOf(filterName) {
+      if (!filterName) {
+        throw new Error('a filter name is required');
+      }
+      for (var index = 0; index < this.filters.length; index++) {
+        var filter = this.filters[index];
+        if (filter.filterName === filterName) {
+          return index;
+        }
+      }
+      throw new Error("filter not found: ".concat(filterName));
+    }
+  }, {
+    key: "list",
+    value: function list() {
+      return this.filters.map(function (f) {
+        return f.filterName;
+      });
+    }
+  }, {
+    key: "after",
+    value: function after(filterName) {
+      var _this$filters3;
+      var index = this.indexOf(filterName);
+      for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        params[_key - 1] = arguments[_key];
+      }
+      (_this$filters3 = this.filters).splice.apply(_this$filters3, [index + 1, 0].concat(params));
+      return this;
+    }
+  }, {
+    key: "before",
+    value: function before(filterName) {
+      var _this$filters4;
+      var index = this.indexOf(filterName);
+      for (var _len2 = arguments.length, params = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        params[_key2 - 1] = arguments[_key2];
+      }
+      (_this$filters4 = this.filters).splice.apply(_this$filters4, [index, 0].concat(params));
+      return this;
+    }
+  }, {
+    key: "replace",
+    value: function replace(filterName) {
+      var _this$filters5;
+      var index = this.indexOf(filterName);
+      for (var _len3 = arguments.length, params = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+        params[_key3 - 1] = arguments[_key3];
+      }
+      (_this$filters5 = this.filters).splice.apply(_this$filters5, [index, 1].concat(params));
+      return this;
+    }
+  }, {
+    key: "remove",
+    value: function remove(filterName) {
+      var index = this.indexOf(filterName);
+      this.filters.splice(index, 1);
+      return this;
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.filters.length = 0;
+      return this;
+    }
+  }, {
+    key: "shouldHaveResult",
+    value: function shouldHaveResult(should) {
+      var _this = this;
+      if (should === false) {
+        this.resultCheck = null;
+        return;
+      }
+      if (this.resultCheck) {
+        return;
+      }
+      this.resultCheck = function (context) {
+        if (!context.hasResult) {
+          console.log(context);
+          var error = new Error("".concat(_this.name, " failed"));
+          error.noResult = true;
+          throw error;
+        }
+      };
+      return this;
+    }
+  }]);
+}();
+
+var Context = /*#__PURE__*/function () {
+  function Context() {
+    _classCallCheck(this, Context);
+  }
+  return _createClass(Context, [{
+    key: "setResult",
+    value: function setResult(result) {
+      this.result = result;
+      this.hasResult = true;
+      return this;
+    }
+  }, {
+    key: "exit",
+    value: function exit() {
+      this.exiting = true;
+      return this;
+    }
+  }, {
+    key: "push",
+    value: function push(child, name) {
+      child.parent = this;
+      if (typeof name !== 'undefined') {
+        child.childName = name;
+      }
+      child.root = this.root || this;
+      child.options = child.options || this.options;
+      if (!this.children) {
+        this.children = [child];
+        this.nextAfterChildren = this.next || null;
+        this.next = child;
+      } else {
+        this.children[this.children.length - 1].next = child;
+        this.children.push(child);
+      }
+      child.next = this;
+      return this;
+    }
+  }]);
+}();
+
+function cloneRegExp(re) {
+  var regexMatch = /^\/(.*)\/([gimyu]*)$/.exec(re.toString());
+  return new RegExp(regexMatch[1], regexMatch[2]);
+}
+function clone$1(arg) {
+  if (_typeof(arg) !== 'object') {
+    return arg;
+  }
+  if (arg === null) {
+    return null;
+  }
+  if (Array.isArray(arg)) {
+    return arg.map(clone$1);
+  }
+  if (arg instanceof Date) {
+    return new Date(arg.getTime());
+  }
+  if (arg instanceof RegExp) {
+    return cloneRegExp(arg);
+  }
+  var cloned = {};
+  for (var name in arg) {
+    if (Object.prototype.hasOwnProperty.call(arg, name)) {
+      cloned[name] = clone$1(arg[name]);
+    }
+  }
+  return cloned;
+}
+
+var DiffContext = /*#__PURE__*/function (_Context) {
+  function DiffContext(left, right) {
+    var _this;
+    _classCallCheck(this, DiffContext);
+    _this = _callSuper(this, DiffContext);
+    _this.left = left;
+    _this.right = right;
+    _this.pipe = 'diff';
+    return _this;
+  }
+  _inherits(DiffContext, _Context);
+  return _createClass(DiffContext, [{
+    key: "setResult",
+    value: function setResult(result) {
+      if (this.options.cloneDiffValues && _typeof(result) === 'object') {
+        var clone = typeof this.options.cloneDiffValues === 'function' ? this.options.cloneDiffValues : clone$1;
+        if (_typeof(result[0]) === 'object') {
+          result[0] = clone(result[0]);
+        }
+        if (_typeof(result[1]) === 'object') {
+          result[1] = clone(result[1]);
+        }
+      }
+      return _superPropGet(DiffContext, "setResult", this, 3)([result]);
+    }
+  }]);
+}(Context);
+
+var PatchContext = /*#__PURE__*/function (_Context) {
+  function PatchContext(left, delta) {
+    var _this;
+    _classCallCheck(this, PatchContext);
+    _this = _callSuper(this, PatchContext);
+    _this.left = left;
+    _this.delta = delta;
+    _this.pipe = 'patch';
+    return _this;
+  }
+  _inherits(PatchContext, _Context);
+  return _createClass(PatchContext);
+}(Context);
+
+var ReverseContext = /*#__PURE__*/function (_Context) {
+  function ReverseContext(delta) {
+    var _this;
+    _classCallCheck(this, ReverseContext);
+    _this = _callSuper(this, ReverseContext);
+    _this.delta = delta;
+    _this.pipe = 'reverse';
+    return _this;
+  }
+  _inherits(ReverseContext, _Context);
+  return _createClass(ReverseContext);
+}(Context);
+
+var diffFilter$3 = function trivialMatchesDiffFilter(context) {
+  if (context.left === context.right) {
+    context.setResult(undefined).exit();
+    return;
+  }
+  if (typeof context.left === 'undefined') {
+    if (typeof context.right === 'function') {
+      throw new Error('functions are not supported');
+    }
+    context.setResult([context.right]).exit();
+    return;
+  }
+  if (typeof context.right === 'undefined') {
+    context.setResult([context.left, 0, 0]).exit();
+    return;
+  }
+  if (typeof context.left === 'function' || typeof context.right === 'function') {
+    throw new Error('functions are not supported');
+  }
+  context.leftType = context.left === null ? 'null' : _typeof(context.left);
+  context.rightType = context.right === null ? 'null' : _typeof(context.right);
+  if (context.leftType !== context.rightType) {
+    context.setResult([context.left, context.right]).exit();
+    return;
+  }
+  if (context.leftType === 'boolean' || context.leftType === 'number') {
+    context.setResult([context.left, context.right]).exit();
+    return;
+  }
+  if (context.leftType === 'object') {
+    context.leftIsArray = Array.isArray(context.left);
+  }
+  if (context.rightType === 'object') {
+    context.rightIsArray = Array.isArray(context.right);
+  }
+  if (context.leftIsArray !== context.rightIsArray) {
+    context.setResult([context.left, context.right]).exit();
+    return;
+  }
+  if (context.left instanceof RegExp) {
+    if (context.right instanceof RegExp) {
+      context.setResult([context.left.toString(), context.right.toString()]).exit();
+    } else {
+      context.setResult([context.left, context.right]).exit();
+    }
+  }
+};
+diffFilter$3.filterName = 'trivial';
+var patchFilter$3 = function trivialMatchesPatchFilter(context) {
+  if (typeof context.delta === 'undefined') {
+    context.setResult(context.left).exit();
+    return;
+  }
+  context.nested = !Array.isArray(context.delta);
+  if (context.nested) {
+    return;
+  }
+  var nonNestedDelta = context.delta;
+  if (nonNestedDelta.length === 1) {
+    context.setResult(nonNestedDelta[0]).exit();
+    return;
+  }
+  if (nonNestedDelta.length === 2) {
+    if (context.left instanceof RegExp) {
+      var regexArgs = /^\/(.*)\/([gimyu]+)$/.exec(nonNestedDelta[1]);
+      if (regexArgs) {
+        context.setResult(new RegExp(regexArgs[1], regexArgs[2])).exit();
+        return;
+      }
+    }
+    context.setResult(nonNestedDelta[1]).exit();
+    return;
+  }
+  if (nonNestedDelta.length === 3 && nonNestedDelta[2] === 0) {
+    context.setResult(undefined).exit();
+  }
+};
+patchFilter$3.filterName = 'trivial';
+var reverseFilter$3 = function trivialReferseFilter(context) {
+  if (typeof context.delta === 'undefined') {
+    context.setResult(context.delta).exit();
+    return;
+  }
+  context.nested = !Array.isArray(context.delta);
+  if (context.nested) {
+    return;
+  }
+  var nonNestedDelta = context.delta;
+  if (nonNestedDelta.length === 1) {
+    context.setResult([nonNestedDelta[0], 0, 0]).exit();
+    return;
+  }
+  if (nonNestedDelta.length === 2) {
+    context.setResult([nonNestedDelta[1], nonNestedDelta[0]]).exit();
+    return;
+  }
+  if (nonNestedDelta.length === 3 && nonNestedDelta[2] === 0) {
+    context.setResult([nonNestedDelta[0]]).exit();
+  }
+};
+reverseFilter$3.filterName = 'trivial';
+
+var collectChildrenDiffFilter = function collectChildrenDiffFilter(context) {
+  if (!context || !context.children) {
+    return;
+  }
+  var length = context.children.length;
+  var child;
+  var result = context.result;
+  for (var index = 0; index < length; index++) {
+    child = context.children[index];
+    if (typeof child.result === 'undefined') {
+      continue;
+    }
+    result = result || {};
+    result[child.childName] = child.result;
+  }
+  if (result && context.leftIsArray) {
+    result._t = 'a';
+  }
+  context.setResult(result).exit();
+};
+collectChildrenDiffFilter.filterName = 'collectChildren';
+var objectsDiffFilter = function objectsDiffFilter(context) {
+  if (context.leftIsArray || context.leftType !== 'object') {
+    return;
+  }
+  var left = context.left;
+  var right = context.right;
+  var name;
+  var child;
+  var propertyFilter = context.options.propertyFilter;
+  for (name in left) {
+    if (!Object.prototype.hasOwnProperty.call(left, name)) {
+      continue;
+    }
+    if (propertyFilter && !propertyFilter(name, context)) {
+      continue;
+    }
+    child = new DiffContext(left[name], right[name]);
+    context.push(child, name);
+  }
+  for (name in right) {
+    if (!Object.prototype.hasOwnProperty.call(right, name)) {
+      continue;
+    }
+    if (propertyFilter && !propertyFilter(name, context)) {
+      continue;
+    }
+    if (typeof left[name] === 'undefined') {
+      child = new DiffContext(undefined, right[name]);
+      context.push(child, name);
+    }
+  }
+  if (!context.children || context.children.length === 0) {
+    context.setResult(undefined).exit();
+    return;
+  }
+  context.exit();
+};
+objectsDiffFilter.filterName = 'objects';
+var patchFilter$2 = function nestedPatchFilter(context) {
+  if (!context.nested) {
+    return;
+  }
+  var nestedDelta = context.delta;
+  if (nestedDelta._t) {
+    return;
+  }
+  var objectDelta = nestedDelta;
+  var name;
+  var child;
+  for (name in objectDelta) {
+    child = new PatchContext(context.left[name], objectDelta[name]);
+    context.push(child, name);
+  }
+  context.exit();
+};
+patchFilter$2.filterName = 'objects';
+var collectChildrenPatchFilter$1 = function collectChildrenPatchFilter(context) {
+  if (!context || !context.children) {
+    return;
+  }
+  var deltaWithChildren = context.delta;
+  if (deltaWithChildren._t) {
+    return;
+  }
+  var object = context.left;
+  var length = context.children.length;
+  var child;
+  for (var index = 0; index < length; index++) {
+    child = context.children[index];
+    var property = child.childName;
+    if (Object.prototype.hasOwnProperty.call(context.left, property) && child.result === undefined) {
+      delete object[property];
+    } else if (object[property] !== child.result) {
+      object[property] = child.result;
+    }
+  }
+  context.setResult(object).exit();
+};
+collectChildrenPatchFilter$1.filterName = 'collectChildren';
+var reverseFilter$2 = function nestedReverseFilter(context) {
+  if (!context.nested) {
+    return;
+  }
+  var nestedDelta = context.delta;
+  if (nestedDelta._t) {
+    return;
+  }
+  var objectDelta = context.delta;
+  var name;
+  var child;
+  for (name in objectDelta) {
+    child = new ReverseContext(objectDelta[name]);
+    context.push(child, name);
+  }
+  context.exit();
+};
+reverseFilter$2.filterName = 'objects';
+var collectChildrenReverseFilter$1 = function collectChildrenReverseFilter(context) {
+  if (!context || !context.children) {
+    return;
+  }
+  var deltaWithChildren = context.delta;
+  if (deltaWithChildren._t) {
+    return;
+  }
+  var length = context.children.length;
+  var child;
+  var delta = {};
+  for (var index = 0; index < length; index++) {
+    child = context.children[index];
+    var property = child.childName;
+    if (delta[property] !== child.result) {
+      delta[property] = child.result;
+    }
+  }
+  context.setResult(delta).exit();
+};
+collectChildrenReverseFilter$1.filterName = 'collectChildren';
+
+/*
+
+LCS implementation that supports arrays or strings
+
+reference: http://en.wikipedia.org/wiki/Longest_common_subsequence_problem
+
+*/
+var defaultMatch = function defaultMatch(array1, array2, index1, index2) {
+  return array1[index1] === array2[index2];
+};
+var lengthMatrix = function lengthMatrix(array1, array2, match, context) {
+  var len1 = array1.length;
+  var len2 = array2.length;
+  var x, y;
+  // initialize empty matrix of len1+1 x len2+1
+  var matrix = new Array(len1 + 1);
+  for (x = 0; x < len1 + 1; x++) {
+    matrix[x] = new Array(len2 + 1);
+    for (y = 0; y < len2 + 1; y++) {
+      matrix[x][y] = 0;
+    }
+  }
+  matrix.match = match;
+  // save sequence lengths for each coordinate
+  for (x = 1; x < len1 + 1; x++) {
+    for (y = 1; y < len2 + 1; y++) {
+      if (match(array1, array2, x - 1, y - 1, context)) {
+        matrix[x][y] = matrix[x - 1][y - 1] + 1;
+      } else {
+        matrix[x][y] = Math.max(matrix[x - 1][y], matrix[x][y - 1]);
+      }
+    }
+  }
+  return matrix;
+};
+var backtrack = function backtrack(matrix, array1, array2, context) {
+  var index1 = array1.length;
+  var index2 = array2.length;
+  var subsequence = {
+    sequence: [],
+    indices1: [],
+    indices2: []
+  };
+  while (index1 !== 0 && index2 !== 0) {
+    var sameLetter = matrix.match(array1, array2, index1 - 1, index2 - 1, context);
+    if (sameLetter) {
+      subsequence.sequence.unshift(array1[index1 - 1]);
+      subsequence.indices1.unshift(index1 - 1);
+      subsequence.indices2.unshift(index2 - 1);
+      --index1;
+      --index2;
+    } else {
+      var valueAtMatrixAbove = matrix[index1][index2 - 1];
+      var valueAtMatrixLeft = matrix[index1 - 1][index2];
+      if (valueAtMatrixAbove > valueAtMatrixLeft) {
+        --index2;
+      } else {
+        --index1;
+      }
+    }
+  }
+  return subsequence;
+};
+var get = function get(array1, array2, match, context) {
+  var innerContext = context || {};
+  var matrix = lengthMatrix(array1, array2, match || defaultMatch, innerContext);
+  return backtrack(matrix, array1, array2, innerContext);
+};
+var lcs = {
+  get: get
+};
+
+var ARRAY_MOVE = 3;
+function arraysHaveMatchByRef(array1, array2, len1, len2) {
+  for (var index1 = 0; index1 < len1; index1++) {
+    var val1 = array1[index1];
+    for (var index2 = 0; index2 < len2; index2++) {
+      var val2 = array2[index2];
+      if (index1 !== index2 && val1 === val2) {
+        return true;
+      }
+    }
+  }
+}
+function matchItems(array1, array2, index1, index2, context) {
+  var value1 = array1[index1];
+  var value2 = array2[index2];
+  if (value1 === value2) {
+    return true;
+  }
+  if (_typeof(value1) !== 'object' || _typeof(value2) !== 'object') {
+    return false;
+  }
+  var objectHash = context.objectHash;
+  if (!objectHash) {
+    // no way to match objects was provided, try match by position
+    return context.matchByPosition && index1 === index2;
+  }
+  context.hashCache1 = context.hashCache1 || [];
+  var hash1 = context.hashCache1[index1];
+  if (typeof hash1 === 'undefined') {
+    context.hashCache1[index1] = hash1 = objectHash(value1, index1);
+  }
+  if (typeof hash1 === 'undefined') {
+    return false;
+  }
+  context.hashCache2 = context.hashCache2 || [];
+  var hash2 = context.hashCache2[index2];
+  if (typeof hash2 === 'undefined') {
+    context.hashCache2[index2] = hash2 = objectHash(value2, index2);
+  }
+  if (typeof hash2 === 'undefined') {
+    return false;
+  }
+  return hash1 === hash2;
+}
+var diffFilter$2 = function arraysDiffFilter(context) {
+  if (!context.leftIsArray) {
+    return;
+  }
+  var matchContext = {
+    objectHash: context.options && context.options.objectHash,
+    matchByPosition: context.options && context.options.matchByPosition
+  };
+  var commonHead = 0;
+  var commonTail = 0;
+  var index;
+  var index1;
+  var index2;
+  var array1 = context.left;
+  var array2 = context.right;
+  var len1 = array1.length;
+  var len2 = array2.length;
+  var child;
+  if (len1 > 0 && len2 > 0 && !matchContext.objectHash && typeof matchContext.matchByPosition !== 'boolean') {
+    matchContext.matchByPosition = !arraysHaveMatchByRef(array1, array2, len1, len2);
+  }
+  // separate common head
+  while (commonHead < len1 && commonHead < len2 && matchItems(array1, array2, commonHead, commonHead, matchContext)) {
+    index = commonHead;
+    child = new DiffContext(array1[index], array2[index]);
+    context.push(child, index);
+    commonHead++;
+  }
+  // separate common tail
+  while (commonTail + commonHead < len1 && commonTail + commonHead < len2 && matchItems(array1, array2, len1 - 1 - commonTail, len2 - 1 - commonTail, matchContext)) {
+    index1 = len1 - 1 - commonTail;
+    index2 = len2 - 1 - commonTail;
+    child = new DiffContext(array1[index1], array2[index2]);
+    context.push(child, index2);
+    commonTail++;
+  }
+  var result;
+  if (commonHead + commonTail === len1) {
+    if (len1 === len2) {
+      // arrays are identical
+      context.setResult(undefined).exit();
+      return;
+    }
+    // trivial case, a block (1 or more consecutive items) was added
+    result = result || {
+      _t: 'a'
+    };
+    for (index = commonHead; index < len2 - commonTail; index++) {
+      result[index] = [array2[index]];
+    }
+    context.setResult(result).exit();
+    return;
+  }
+  if (commonHead + commonTail === len2) {
+    // trivial case, a block (1 or more consecutive items) was removed
+    result = result || {
+      _t: 'a'
+    };
+    for (index = commonHead; index < len1 - commonTail; index++) {
+      result["_".concat(index)] = [array1[index], 0, 0];
+    }
+    context.setResult(result).exit();
+    return;
+  }
+  // reset hash cache
+  delete matchContext.hashCache1;
+  delete matchContext.hashCache2;
+  // diff is not trivial, find the LCS (Longest Common Subsequence)
+  var trimmed1 = array1.slice(commonHead, len1 - commonTail);
+  var trimmed2 = array2.slice(commonHead, len2 - commonTail);
+  var seq = lcs.get(trimmed1, trimmed2, matchItems, matchContext);
+  var removedItems = [];
+  result = result || {
+    _t: 'a'
+  };
+  for (index = commonHead; index < len1 - commonTail; index++) {
+    if (seq.indices1.indexOf(index - commonHead) < 0) {
+      // removed
+      result["_".concat(index)] = [array1[index], 0, 0];
+      removedItems.push(index);
+    }
+  }
+  var detectMove = true;
+  if (context.options && context.options.arrays && context.options.arrays.detectMove === false) {
+    detectMove = false;
+  }
+  var includeValueOnMove = false;
+  if (context.options && context.options.arrays && context.options.arrays.includeValueOnMove) {
+    includeValueOnMove = true;
+  }
+  var removedItemsLength = removedItems.length;
+  for (index = commonHead; index < len2 - commonTail; index++) {
+    var indexOnArray2 = seq.indices2.indexOf(index - commonHead);
+    if (indexOnArray2 < 0) {
+      // added, try to match with a removed item and register as position move
+      var isMove = false;
+      if (detectMove && removedItemsLength > 0) {
+        for (var removeItemIndex1 = 0; removeItemIndex1 < removedItemsLength; removeItemIndex1++) {
+          index1 = removedItems[removeItemIndex1];
+          if (matchItems(trimmed1, trimmed2, index1 - commonHead, index - commonHead, matchContext)) {
+            // store position move as: [originalValue, newPosition, ARRAY_MOVE]
+            result["_".concat(index1)].splice(1, 2, index, ARRAY_MOVE);
+            if (!includeValueOnMove) {
+              // don't include moved value on diff, to save bytes
+              result["_".concat(index1)][0] = '';
+            }
+            index2 = index;
+            child = new DiffContext(array1[index1], array2[index2]);
+            context.push(child, index2);
+            removedItems.splice(removeItemIndex1, 1);
+            isMove = true;
+            break;
+          }
+        }
+      }
+      if (!isMove) {
+        // added
+        result[index] = [array2[index]];
+      }
+    } else {
+      // match, do inner diff
+      index1 = seq.indices1[indexOnArray2] + commonHead;
+      index2 = seq.indices2[indexOnArray2] + commonHead;
+      child = new DiffContext(array1[index1], array2[index2]);
+      context.push(child, index2);
+    }
+  }
+  context.setResult(result).exit();
+};
+diffFilter$2.filterName = 'arrays';
+var compare = {
+  numerically: function numerically(a, b) {
+    return a - b;
+  },
+  numericallyBy: function numericallyBy(name) {
+    return function (a, b) {
+      return a[name] - b[name];
+    };
+  }
+};
+var patchFilter$1 = function nestedPatchFilter(context) {
+  if (!context.nested) {
+    return;
+  }
+  var nestedDelta = context.delta;
+  if (nestedDelta._t !== 'a') {
+    return;
+  }
+  var index;
+  var index1;
+  var delta = nestedDelta;
+  var array = context.left;
+  // first, separate removals, insertions and modifications
+  var toRemove = [];
+  var toInsert = [];
+  var toModify = [];
+  for (index in delta) {
+    if (index !== '_t') {
+      if (index[0] === '_') {
+        var removedOrMovedIndex = index;
+        // removed item from original array
+        if (delta[removedOrMovedIndex][2] === 0 || delta[removedOrMovedIndex][2] === ARRAY_MOVE) {
+          toRemove.push(parseInt(index.slice(1), 10));
+        } else {
+          throw new Error('only removal or move can be applied at original array indices,' + " invalid diff type: ".concat(delta[removedOrMovedIndex][2]));
+        }
+      } else {
+        var numberIndex = index;
+        if (delta[numberIndex].length === 1) {
+          // added item at new array
+          toInsert.push({
+            index: parseInt(numberIndex, 10),
+            value: delta[numberIndex][0]
+          });
+        } else {
+          // modified item at new array
+          toModify.push({
+            index: parseInt(numberIndex, 10),
+            delta: delta[numberIndex]
+          });
+        }
+      }
+    }
+  }
+  // remove items, in reverse order to avoid sawing our own floor
+  toRemove = toRemove.sort(compare.numerically);
+  for (index = toRemove.length - 1; index >= 0; index--) {
+    index1 = toRemove[index];
+    var indexDiff = delta["_".concat(index1)];
+    var removedValue = array.splice(index1, 1)[0];
+    if (indexDiff[2] === ARRAY_MOVE) {
+      // reinsert later
+      toInsert.push({
+        index: indexDiff[1],
+        value: removedValue
+      });
+    }
+  }
+  // insert items, in reverse order to avoid moving our own floor
+  toInsert = toInsert.sort(compare.numericallyBy('index'));
+  var toInsertLength = toInsert.length;
+  for (index = 0; index < toInsertLength; index++) {
+    var insertion = toInsert[index];
+    array.splice(insertion.index, 0, insertion.value);
+  }
+  // apply modifications
+  var toModifyLength = toModify.length;
+  var child;
+  if (toModifyLength > 0) {
+    for (index = 0; index < toModifyLength; index++) {
+      var modification = toModify[index];
+      child = new PatchContext(array[modification.index], modification.delta);
+      context.push(child, modification.index);
+    }
+  }
+  if (!context.children) {
+    context.setResult(array).exit();
+    return;
+  }
+  context.exit();
+};
+patchFilter$1.filterName = 'arrays';
+var collectChildrenPatchFilter = function collectChildrenPatchFilter(context) {
+  if (!context || !context.children) {
+    return;
+  }
+  var deltaWithChildren = context.delta;
+  if (deltaWithChildren._t !== 'a') {
+    return;
+  }
+  var array = context.left;
+  var length = context.children.length;
+  var child;
+  for (var index = 0; index < length; index++) {
+    child = context.children[index];
+    var arrayIndex = child.childName;
+    array[arrayIndex] = child.result;
+  }
+  context.setResult(array).exit();
+};
+collectChildrenPatchFilter.filterName = 'arraysCollectChildren';
+var reverseFilter$1 = function arraysReverseFilter(context) {
+  if (!context.nested) {
+    var nonNestedDelta = context.delta;
+    if (nonNestedDelta[2] === ARRAY_MOVE) {
+      var arrayMoveDelta = nonNestedDelta;
+      context.newName = "_".concat(arrayMoveDelta[1]);
+      context.setResult([arrayMoveDelta[0], parseInt(context.childName.substring(1), 10), ARRAY_MOVE]).exit();
+    }
+    return;
+  }
+  var nestedDelta = context.delta;
+  if (nestedDelta._t !== 'a') {
+    return;
+  }
+  var arrayDelta = nestedDelta;
+  var name;
+  var child;
+  for (name in arrayDelta) {
+    if (name === '_t') {
+      continue;
+    }
+    child = new ReverseContext(arrayDelta[name]);
+    context.push(child, name);
+  }
+  context.exit();
+};
+reverseFilter$1.filterName = 'arrays';
+var reverseArrayDeltaIndex = function reverseArrayDeltaIndex(delta, index, itemDelta) {
+  if (typeof index === 'string' && index[0] === '_') {
+    return parseInt(index.substring(1), 10);
+  } else if (Array.isArray(itemDelta) && itemDelta[2] === 0) {
+    return "_".concat(index);
+  }
+  var reverseIndex = +index;
+  for (var deltaIndex in delta) {
+    var deltaItem = delta[deltaIndex];
+    if (Array.isArray(deltaItem)) {
+      if (deltaItem[2] === ARRAY_MOVE) {
+        var moveFromIndex = parseInt(deltaIndex.substring(1), 10);
+        var moveToIndex = deltaItem[1];
+        if (moveToIndex === +index) {
+          return moveFromIndex;
+        }
+        if (moveFromIndex <= reverseIndex && moveToIndex > reverseIndex) {
+          reverseIndex++;
+        } else if (moveFromIndex >= reverseIndex && moveToIndex < reverseIndex) {
+          reverseIndex--;
+        }
+      } else if (deltaItem[2] === 0) {
+        var deleteIndex = parseInt(deltaIndex.substring(1), 10);
+        if (deleteIndex <= reverseIndex) {
+          reverseIndex++;
+        }
+      } else if (deltaItem.length === 1 && parseInt(deltaIndex, 10) <= reverseIndex) {
+        reverseIndex--;
+      }
+    }
+  }
+  return reverseIndex;
+};
+var collectChildrenReverseFilter = function collectChildrenReverseFilter(context) {
+  if (!context || !context.children) {
+    return;
+  }
+  var deltaWithChildren = context.delta;
+  if (deltaWithChildren._t !== 'a') {
+    return;
+  }
+  var arrayDelta = deltaWithChildren;
+  var length = context.children.length;
+  var child;
+  var delta = {
+    _t: 'a'
+  };
+  for (var index = 0; index < length; index++) {
+    child = context.children[index];
+    var name = child.newName;
+    if (typeof name === 'undefined') {
+      name = reverseArrayDeltaIndex(arrayDelta, child.childName, child.result);
+    }
+    if (delta[name] !== child.result) {
+      // There's no way to type this well.
+      delta[name] = child.result;
+    }
+  }
+  context.setResult(delta).exit();
+};
+collectChildrenReverseFilter.filterName = 'arraysCollectChildren';
+
+var diffFilter$1 = function datesDiffFilter(context) {
+  if (context.left instanceof Date) {
+    if (context.right instanceof Date) {
+      if (context.left.getTime() !== context.right.getTime()) {
+        context.setResult([context.left, context.right]);
+      } else {
+        context.setResult(undefined);
+      }
+    } else {
+      context.setResult([context.left, context.right]);
+    }
+    context.exit();
+  } else if (context.right instanceof Date) {
+    context.setResult([context.left, context.right]).exit();
+  }
+};
+diffFilter$1.filterName = 'dates';
+
+var TEXT_DIFF = 2;
+var DEFAULT_MIN_LENGTH = 60;
+var cachedDiffPatch = null;
+function getDiffMatchPatch(options, required) {
+  var _a;
+  if (!cachedDiffPatch) {
+    var instance;
+    if ((_a = options === null || options === void 0 ? void 0 : options.textDiff) === null || _a === void 0 ? void 0 : _a.diffMatchPatch) {
+      instance = new options.textDiff.diffMatchPatch();
+    } else {
+      if (!required) {
+        return null;
+      }
+      var error = new Error('The diff-match-patch library was not provided. Pass the library in through the options or use the `jsondiffpatch/with-text-diffs` entry-point.');
+      // eslint-disable-next-line camelcase
+      error.diff_match_patch_not_found = true;
+      throw error;
+    }
+    cachedDiffPatch = {
+      diff: function diff(txt1, txt2) {
+        return instance.patch_toText(instance.patch_make(txt1, txt2));
+      },
+      patch: function patch(txt1, _patch) {
+        var results = instance.patch_apply(instance.patch_fromText(_patch), txt1);
+        for (var i = 0; i < results[1].length; i++) {
+          if (!results[1][i]) {
+            var _error = new Error('text patch failed');
+            _error.textPatchFailed = true;
+          }
+        }
+        return results[0];
+      }
+    };
+  }
+  return cachedDiffPatch;
+}
+var diffFilter = function textsDiffFilter(context) {
+  if (context.leftType !== 'string') {
+    return;
+  }
+  var left = context.left;
+  var right = context.right;
+  var minLength = context.options && context.options.textDiff && context.options.textDiff.minLength || DEFAULT_MIN_LENGTH;
+  if (left.length < minLength || right.length < minLength) {
+    context.setResult([left, right]).exit();
+    return;
+  }
+  // large text, try to use a text-diff algorithm
+  var diffMatchPatch = getDiffMatchPatch(context.options);
+  if (!diffMatchPatch) {
+    // diff-match-patch library not available,
+    // fallback to regular string replace
+    context.setResult([left, right]).exit();
+    return;
+  }
+  var diff = diffMatchPatch.diff;
+  context.setResult([diff(left, right), 0, TEXT_DIFF]).exit();
+};
+diffFilter.filterName = 'texts';
+var patchFilter = function textsPatchFilter(context) {
+  if (context.nested) {
+    return;
+  }
+  var nonNestedDelta = context.delta;
+  if (nonNestedDelta[2] !== TEXT_DIFF) {
+    return;
+  }
+  var textDiffDelta = nonNestedDelta;
+  // text-diff, use a text-patch algorithm
+  var patch = getDiffMatchPatch(context.options, true).patch;
+  context.setResult(patch(context.left, textDiffDelta[0])).exit();
+};
+patchFilter.filterName = 'texts';
+var textDeltaReverse = function textDeltaReverse(delta) {
+  var i;
+  var l;
+  var line;
+  var lineTmp;
+  var header = null;
+  var headerRegex = /^@@ +-(\d+),(\d+) +\+(\d+),(\d+) +@@$/;
+  var lineHeader;
+  var lines = delta.split('\n');
+  for (i = 0, l = lines.length; i < l; i++) {
+    line = lines[i];
+    var lineStart = line.slice(0, 1);
+    if (lineStart === '@') {
+      header = headerRegex.exec(line);
+      lineHeader = i;
+      // fix header
+      lines[lineHeader] = '@@ -' + header[3] + ',' + header[4] + ' +' + header[1] + ',' + header[2] + ' @@';
+    } else if (lineStart === '+') {
+      lines[i] = '-' + lines[i].slice(1);
+      if (lines[i - 1].slice(0, 1) === '+') {
+        // swap lines to keep default order (-+)
+        lineTmp = lines[i];
+        lines[i] = lines[i - 1];
+        lines[i - 1] = lineTmp;
+      }
+    } else if (lineStart === '-') {
+      lines[i] = '+' + lines[i].slice(1);
+    }
+  }
+  return lines.join('\n');
+};
+var reverseFilter = function textsReverseFilter(context) {
+  if (context.nested) {
+    return;
+  }
+  var nonNestedDelta = context.delta;
+  if (nonNestedDelta[2] !== TEXT_DIFF) {
+    return;
+  }
+  var textDiffDelta = nonNestedDelta;
+  // text-diff, use a text-diff algorithm
+  context.setResult([textDeltaReverse(textDiffDelta[0]), 0, TEXT_DIFF]).exit();
+};
+reverseFilter.filterName = 'texts';
+
+var DiffPatcher = /*#__PURE__*/function () {
+  function DiffPatcher(options) {
+    _classCallCheck(this, DiffPatcher);
+    this.processor = new Processor(options);
+    this.processor.pipe(new Pipe('diff').append(collectChildrenDiffFilter, diffFilter$3, diffFilter$1, diffFilter, objectsDiffFilter, diffFilter$2).shouldHaveResult());
+    this.processor.pipe(new Pipe('patch').append(collectChildrenPatchFilter$1, collectChildrenPatchFilter, patchFilter$3, patchFilter, patchFilter$2, patchFilter$1).shouldHaveResult());
+    this.processor.pipe(new Pipe('reverse').append(collectChildrenReverseFilter$1, collectChildrenReverseFilter, reverseFilter$3, reverseFilter, reverseFilter$2, reverseFilter$1).shouldHaveResult());
+  }
+  return _createClass(DiffPatcher, [{
+    key: "options",
+    value: function options(_options) {
+      return this.processor.options(_options);
+    }
+  }, {
+    key: "diff",
+    value: function diff(left, right) {
+      return this.processor.process(new DiffContext(left, right));
+    }
+  }, {
+    key: "patch",
+    value: function patch(left, delta) {
+      return this.processor.process(new PatchContext(left, delta));
+    }
+  }, {
+    key: "reverse",
+    value: function reverse(delta) {
+      return this.processor.process(new ReverseContext(delta));
+    }
+  }, {
+    key: "unpatch",
+    value: function unpatch(right, delta) {
+      return this.patch(right, this.reverse(delta));
+    }
+  }, {
+    key: "clone",
+    value: function clone(value) {
+      return clone$1(value);
+    }
+  }]);
+}();
+
 function objectHash(obj, index) {
   var objIndex = "$$index:".concat(index);
   return _typeof(obj) === 'object' && obj !== null ? obj.id || obj.name || obj.url || objIndex : objIndex;
@@ -673,7 +1947,6 @@ function actionsMapReferences$3(diff, oldObj, newObj) {
   return buildReferenceActions({
     actions: referenceActionsList$3,
     diff: diff,
-    oldObj: oldObj,
     newObj: newObj
   });
 }
@@ -889,7 +2162,6 @@ function actionsMapReferences$2(diff, oldObj, newObj) {
   return buildReferenceActions({
     actions: referenceActionsList$2,
     diff: diff,
-    oldObj: oldObj,
     newObj: newObj
   });
 }
@@ -1087,7 +2359,6 @@ function actionsMapReferences$1(diff, oldObj, newObj) {
   return buildReferenceActions({
     actions: referenceActionsList$1,
     diff: diff,
-    oldObj: oldObj,
     newObj: newObj
   });
 }
@@ -1634,7 +2905,6 @@ function actionsMapReferences(diff, oldObj, newObj) {
   return buildReferenceActions({
     actions: referenceActionsList,
     diff: diff,
-    oldObj: oldObj,
     newObj: newObj
   });
 }