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

package/dist/sync-actions.umd.js

@@ -1,19 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash.flatten'), require('lodash.isequal'), require('lodash.isnil'), require('jsondiffpatch/dist/jsondiffpatch.cjs'), require('lodash.foreach'), require('lodash.uniqwith'), require('lodash.intersection'), require('lodash.without'), require('lodash.sortby')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'lodash.flatten', 'lodash.isequal', 'lodash.isnil', 'jsondiffpatch/dist/jsondiffpatch.cjs', 'lodash.foreach', 'lodash.uniqwith', 'lodash.intersection', 'lodash.without', 'lodash.sortby'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.CommercetoolsSyncActions = {}, global.flatten, global.isEqual, global.isNil, global.jsondiffpatch_cjs, global.forEach, global.uniqWith, global.intersection, global.without, global.sortBy));
-})(this, (function (exports, flatten, isEqual, isNil, jsondiffpatch_cjs, forEach, uniqWith, intersection, without, sortBy) { 'use strict';
-
-  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-  var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
-  var isEqual__default = /*#__PURE__*/_interopDefaultLegacy(isEqual);
-  var isNil__default = /*#__PURE__*/_interopDefaultLegacy(isNil);
-  var forEach__default = /*#__PURE__*/_interopDefaultLegacy(forEach);
-  var uniqWith__default = /*#__PURE__*/_interopDefaultLegacy(uniqWith);
-  var intersection__default = /*#__PURE__*/_interopDefaultLegacy(intersection);
-  var without__default = /*#__PURE__*/_interopDefaultLegacy(without);
-  var sortBy__default = /*#__PURE__*/_interopDefaultLegacy(sortBy);
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash.flatten'), require('lodash.isequal'), require('lodash.isnil'), require('lodash.foreach'), require('lodash.uniqwith'), require('lodash.intersection'), require('lodash.without'), require('lodash.sortby')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'lodash.flatten', 'lodash.isequal', 'lodash.isnil', 'lodash.foreach', 'lodash.uniqwith', 'lodash.intersection', 'lodash.without', 'lodash.sortby'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.CommercetoolsSyncActions = {}, global.flatten, global.isEqual, global.isNil, global.forEach, global.uniqWith, global.intersection, global.without, global.sortBy));
+})(this, (function (exports, flatten, isEqual, isNil, forEach, uniqWith, intersection, without, sortBy) { 'use strict';
 
   function _arrayLikeToArray(r, a) {
     (null == a || a > r.length) && (a = r.length);
@@ -26,14 +15,69 @@
   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);
   }
@@ -45,15 +89,15 @@
         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;
@@ -83,7 +127,7 @@
   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));
@@ -97,8 +141,8 @@
       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;
   }
@@ -106,14 +150,34 @@
     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();
   }
@@ -121,11 +185,11 @@
     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");
@@ -167,7 +231,7 @@
   function arePricesStructurallyEqual(oldPrice, newPrice) {
     var oldPriceComparison = createPriceComparator(oldPrice);
     var newPriceComparison = createPriceComparator(newPrice);
-    return isEqual__default["default"](newPriceComparison, oldPriceComparison);
+    return isEqual(newPriceComparison, oldPriceComparison);
   }
   function extractPriceFromPreviousVariant(newPrice, previousVariant) {
     if (!previousVariant) return null;
@@ -182,7 +246,7 @@
         restOfVariant = _objectWithoutProperties(newVariant, _excluded$2);
       if (!prices) return restOfVariant;
       var oldVariant = previousVariants.find(function (previousVariant) {
-        return !isNil__default["default"](previousVariant.id) && previousVariant.id === newVariant.id || !isNil__default["default"](previousVariant.key) && previousVariant.key === newVariant.key || !isNil__default["default"](previousVariant.sku) && previousVariant.sku === newVariant.sku;
+        return !isNil(previousVariant.id) && previousVariant.id === newVariant.id || !isNil(previousVariant.key) && previousVariant.key === newVariant.key || !isNil(previousVariant.sku) && previousVariant.sku === newVariant.sku;
       });
       return _objectSpread2(_objectSpread2({}, restOfVariant), {}, {
         prices: prices.map(function (price) {
@@ -191,8 +255,8 @@
           if (oldPrice) {
             // copy ID if not provided
             if (!newPrice.id) newPrice.id = oldPrice.id;
-            if (isNil__default["default"](newPrice.value.type)) newPrice.value.type = oldPrice.value.type;
-            if (isNil__default["default"](newPrice.value.fractionDigits)) newPrice.value.fractionDigits = oldPrice.value.fractionDigits;
+            if (isNil(newPrice.value.type)) newPrice.value.type = oldPrice.value.type;
+            if (isNil(newPrice.value.fractionDigits)) newPrice.value.fractionDigits = oldPrice.value.fractionDigits;
           }
           return newPrice;
         })
@@ -239,11 +303,1211 @@
     };
   }
 
+  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;
   }
-  var diffpatcher = new jsondiffpatch_cjs.DiffPatcher({
+  var diffpatcher = new DiffPatcher({
     objectHash: objectHash,
     arrays: {
       // detect items moved inside the array
@@ -573,7 +1837,7 @@
         action: item.action
       }, actionKey, patched);
     }).filter(function (action) {
-      return !isNil__default["default"](action);
+      return !isNil(action);
     });
   }
 
@@ -680,7 +1944,6 @@
     return buildReferenceActions({
       actions: referenceActionsList$3,
       diff: diff,
-      oldObj: oldObj,
       newObj: newObj
     });
   }
@@ -706,7 +1969,7 @@
   function copyEmptyArrayProps() {
     var oldObj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     var newObj = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    if (!isNil__default["default"](oldObj) && !isNil__default["default"](newObj)) {
+    if (!isNil(oldObj) && !isNil(newObj)) {
       var nextObjectWithEmptyArray = Object.entries(oldObj).reduce(function (merged, _ref) {
         var _ref2 = _slicedToArray(_ref, 2),
           key = _ref2[0],
@@ -721,10 +1984,10 @@
             return acc;
           }, {});
           for (var i = 0; i < newObj[key].length; i++) {
-            if (!isNil__default["default"](newObj[key][i]) && _typeof(newObj[key][i]) === 'object' && !isNil__default["default"](newObj[key][i].id)) {
+            if (!isNil(newObj[key][i]) && _typeof(newObj[key][i]) === 'object' && !isNil(newObj[key][i].id)) {
               // Since its unordered array elements then check if the element on `oldObj` exists by id
               var foundObject = hashMapValue[newObj[key][i].id];
-              if (!isNil__default["default"](foundObject)) {
+              if (!isNil(foundObject)) {
                 var _copyEmptyArrayProps = copyEmptyArrayProps(foundObject, newObj[key][i]),
                   _copyEmptyArrayProps2 = _slicedToArray(_copyEmptyArrayProps, 2),
                   nestedObject = _copyEmptyArrayProps2[1];
@@ -740,10 +2003,10 @@
           return merged;
         }
         if (Array.isArray(value)) {
-          merged[key] = isNil__default["default"](newObj[key]) ? [] : newObj[key];
+          merged[key] = isNil(newObj[key]) ? [] : newObj[key];
           return merged;
         }
-        if (!isNil__default["default"](newObj[key]) && _typeof(value) === 'object' &&
+        if (!isNil(newObj[key]) && _typeof(value) === 'object' &&
         // Ignore Date as this will create invalid object since typeof date === 'object' return true
         // ex: {date: new Date()} will result {date: {}}
         !(value instanceof Date)) {
@@ -778,7 +2041,7 @@
       allActions.push(mapActionGroup('assets', function () {
         return actionsMapAssets$1(diff, oldObj, newObj);
       }));
-      return flatten__default["default"](allActions);
+      return flatten(allActions);
     };
   }
   var categories = (function (actionGroupList, syncActionConfig) {
@@ -896,7 +2159,6 @@
     return buildReferenceActions({
       actions: referenceActionsList$2,
       diff: diff,
-      oldObj: oldObj,
       newObj: newObj
     });
   }
@@ -1004,7 +2266,7 @@
         authMode: patched
       }, value, newObj.password);
     }).filter(function (action) {
-      return !isNil__default["default"](action);
+      return !isNil(action);
     });
   }
 
@@ -1035,7 +2297,7 @@
       allActions.push(mapActionGroup('authenticationModes', function () {
         return actionsMapAuthenticationModes(diff, oldObj, newObj);
       }));
-      return flatten__default["default"](allActions);
+      return flatten(allActions);
     };
   }
   var customers = (function (actionGroupList, syncActionConfig) {
@@ -1094,7 +2356,6 @@
     return buildReferenceActions({
       actions: referenceActionsList$1,
       diff: diff,
-      oldObj: oldObj,
       newObj: newObj
     });
   }
@@ -1111,7 +2372,7 @@
       allActions.push(mapActionGroup('custom', function () {
         return actionsMapCustom(diff, newObj, oldObj);
       }));
-      return flatten__default["default"](allActions);
+      return flatten(allActions);
     };
   }
   var inventories = (function (actionGroupList, syncActionConfig) {
@@ -1178,7 +2439,7 @@
     var _preProcessCollection2 = preProcessCollection(now, identifier),
       nowObjRefByIdentifier = _preProcessCollection2.refByIdentifier,
       nowObjRefByIndex = _preProcessCollection2.refByIndex;
-    forEach__default["default"](diff, function (item, key) {
+    forEach(diff, function (item, key) {
       if (REGEX_NUMBER$3.test(key)) {
         var matchingIdentifier = nowObjRefByIndex[key];
         result[key] = [beforeObjRefByIdentifier[matchingIdentifier], key];
@@ -1359,7 +2620,7 @@
     var actions = [];
     // generate a hashMap to be able to reference the right image from both ends
     var matchingImagePairs = findMatchingPairs(diffedImages, oldVariant.images, newVariant.images, 'url');
-    forEach__default["default"](diffedImages, function (image, key) {
+    forEach(diffedImages, function (image, key) {
       var _extractMatchingPairs = extractMatchingPairs(matchingImagePairs, key, oldVariant.images, newVariant.images),
         oldObj = _extractMatchingPairs.oldObj,
         newObj = _extractMatchingPairs.newObj;
@@ -1416,7 +2677,7 @@
 
     // generate a hashMap to be able to reference the right image from both ends
     var matchingPricePairs = findMatchingPairs(diffedPrices, oldVariant.prices, newVariant.prices);
-    forEach__default["default"](diffedPrices, function (price, key) {
+    forEach(diffedPrices, function (price, key) {
       var _extractMatchingPairs2 = extractMatchingPairs(matchingPricePairs, key, oldVariant.prices, newVariant.prices),
         oldObj = _extractMatchingPairs2.oldObj,
         newObj = _extractMatchingPairs2.newObj;
@@ -1464,7 +2725,7 @@
   function _buildVariantAttributesActions(attributes, oldVariant, newVariant, sameForAllAttributeNames) {
     var actions = [];
     if (!attributes) return actions;
-    forEach__default["default"](attributes, function (value, key) {
+    forEach(attributes, function (value, key) {
       if (REGEX_NUMBER$2.test(key)) {
         if (Array.isArray(value)) {
           var id = oldVariant.id;
@@ -1529,8 +2790,8 @@
     }).filter(function (_) {
       return _ !== undefined;
     });
-    var assetIdsToKeep = intersection__default["default"](assetIdsCurrent, assetIdsBefore);
-    var assetIdsToRemove = without__default["default"].apply(void 0, [assetIdsBefore].concat(_toConsumableArray(assetIdsToKeep)));
+    var assetIdsToKeep = intersection(assetIdsCurrent, assetIdsBefore);
+    var assetIdsToRemove = without.apply(void 0, [assetIdsBefore].concat(_toConsumableArray(assetIdsToKeep)));
     var changeAssetOrderAction = _objectSpread2({
       action: 'changeAssetOrder',
       assetOrder: assetIdsToKeep.concat(assetIdsToRemove)
@@ -1542,7 +2803,7 @@
 
     // generate a hashMap to be able to reference the right asset from both ends
     var matchingAssetPairs = findMatchingPairs(diffAssets, oldVariant.assets, newVariant.assets);
-    forEach__default["default"](diffAssets, function (asset, key) {
+    forEach(diffAssets, function (asset, key) {
       var _extractMatchingPairs3 = extractMatchingPairs(matchingAssetPairs, key, oldVariant.assets, newVariant.assets),
         oldAsset = _extractMatchingPairs3.oldObj,
         newAsset = _extractMatchingPairs3.newObj;
@@ -1641,7 +2902,6 @@
     return buildReferenceActions({
       actions: referenceActionsList,
       diff: diff,
-      oldObj: oldObj,
       newObj: newObj
     });
   }
@@ -1650,7 +2910,7 @@
     if (!diff.categories) return actions;
     var addToCategoryActions = [];
     var removeFromCategoryActions = [];
-    forEach__default["default"](diff.categories, function (category) {
+    forEach(diff.categories, function (category) {
       if (Array.isArray(category)) {
         var action = {
           category: category[0]
@@ -1695,7 +2955,7 @@
   function actionsMapAssets(diff, oldObj, newObj, variantHashMap) {
     var allAssetsActions = [];
     var variants = diff.variants;
-    if (variants) forEach__default["default"](variants, function (variant, key) {
+    if (variants) forEach(variants, function (variant, key) {
       var _extractMatchingPairs4 = extractMatchingPairs(variantHashMap, key, oldObj.variants, newObj.variants),
         oldVariant = _extractMatchingPairs4.oldObj,
         newVariant = _extractMatchingPairs4.newObj;
@@ -1711,7 +2971,7 @@
     var variantHashMap = arguments.length > 4 ? arguments[4] : undefined;
     var actions = [];
     var variants = diff.variants;
-    if (variants) forEach__default["default"](variants, function (variant, key) {
+    if (variants) forEach(variants, function (variant, key) {
       var _extractMatchingPairs5 = extractMatchingPairs(variantHashMap, key, oldObj.variants, newObj.variants),
         oldVariant = _extractMatchingPairs5.oldObj,
         newVariant = _extractMatchingPairs5.newObj;
@@ -1728,14 +2988,14 @@
 
     // Ensure that an action is unique.
     // This is especially necessary for SFA attributes.
-    return uniqWith__default["default"](actions, function (a, b) {
+    return uniqWith(actions, function (a, b) {
       return a.action === b.action && a.name === b.name && a.variantId === b.variantId;
     });
   }
   function actionsMapImages(diff, oldObj, newObj, variantHashMap) {
     var actions = [];
     var variants = diff.variants;
-    if (variants) forEach__default["default"](variants, function (variant, key) {
+    if (variants) forEach(variants, function (variant, key) {
       var _extractMatchingPairs6 = extractMatchingPairs(variantHashMap, key, oldObj.variants, newObj.variants),
         oldVariant = _extractMatchingPairs6.oldObj,
         newVariant = _extractMatchingPairs6.newObj;
@@ -1751,7 +3011,7 @@
     var changePriceActions = [];
     var removePriceActions = [];
     var variants = diff.variants;
-    if (variants) forEach__default["default"](variants, function (variant, key) {
+    if (variants) forEach(variants, function (variant, key) {
       var _extractMatchingPairs7 = extractMatchingPairs(variantHashMap, key, oldObj.variants, newObj.variants),
         oldVariant = _extractMatchingPairs7.oldObj,
         newVariant = _extractMatchingPairs7.newObj;
@@ -1773,13 +3033,13 @@
   function actionsMapPricesCustom(diff, oldObj, newObj, variantHashMap) {
     var actions = [];
     var variants = diff.variants;
-    if (variants) forEach__default["default"](variants, function (variant, key) {
+    if (variants) forEach(variants, function (variant, key) {
       var _extractMatchingPairs8 = extractMatchingPairs(variantHashMap, key, oldObj.variants, newObj.variants),
         oldVariant = _extractMatchingPairs8.oldObj,
         newVariant = _extractMatchingPairs8.newObj;
       if (variant && variant.prices && (REGEX_UNDERSCORE_NUMBER$2.test(key) || REGEX_NUMBER$2.test(key))) {
         var priceHashMap = findMatchingPairs(variant.prices, oldVariant.prices, newVariant.prices);
-        forEach__default["default"](variant.prices, function (price, index) {
+        forEach(variant.prices, function (price, index) {
           var _extractMatchingPairs9 = extractMatchingPairs(priceHashMap, index, oldVariant.prices, newVariant.prices),
             oldPrice = _extractMatchingPairs9.oldObj,
             newPrice = _extractMatchingPairs9.newObj;
@@ -1863,12 +3123,12 @@
       allActions.push(mapActionGroup('assets', function () {
         return actionsMapAssets(diff, oldObj, newObj, variantHashMap);
       }));
-      if (publish === true || staged === false) return flatten__default["default"](allActions).map(function (action) {
+      if (publish === true || staged === false) return flatten(allActions).map(function (action) {
         return _objectSpread2(_objectSpread2({}, action), {}, {
           staged: false
         });
       });
-      return flatten__default["default"](allActions);
+      return flatten(allActions);
     };
   }
   function moveMasterVariantsIntoVariants(before, now) {
@@ -1951,7 +3211,7 @@
 
     // generate a hashMap to be able to reference the right image from both ends
     var matchingParcelPairs = findMatchingPairs(diffedParcels, oldDelivery.parcels, newDelivery.parcels);
-    forEach__default["default"](diffedParcels, function (parcel, key) {
+    forEach(diffedParcels, function (parcel, key) {
       var _extractMatchingPairs = extractMatchingPairs(matchingParcelPairs, key, oldDelivery.parcels, newDelivery.parcels),
         oldObj = _extractMatchingPairs.oldObj;
       if (isAddAction(key, parcel)) {
@@ -1993,7 +3253,7 @@
     if (!deliveries) return [];
     var addParcelActions = [];
     var removeParcelActions = [];
-    if (deliveries) forEach__default["default"](deliveries, function (delivery, key) {
+    if (deliveries) forEach(deliveries, function (delivery, key) {
       var _extractMatchingPairs2 = extractMatchingPairs(deliveryHashMap, key, oldObj.shippingInfo.deliveries, newObj.shippingInfo.deliveries),
         oldDelivery = _extractMatchingPairs2.oldObj,
         newDelivery = _extractMatchingPairs2.newObj;
@@ -2014,7 +3274,7 @@
     var deliveries = shippingInfo.deliveries;
     if (!deliveries) return [];
     var setDeliveryItemsActions = [];
-    forEach__default["default"](deliveries, function (delivery, key) {
+    forEach(deliveries, function (delivery, key) {
       var _extractMatchingPairs3 = extractMatchingPairs(deliveryHashMap, key, oldObj.shippingInfo.deliveries, newObj.shippingInfo.deliveries),
         newDelivery = _extractMatchingPairs3.newObj;
       if (REGEX_UNDERSCORE_NUMBER$1.test(key) || REGEX_NUMBER$1.test(key)) {
@@ -2083,13 +3343,13 @@
       allActions.push(mapActionGroup('items', function () {
         return actionsMapDeliveryItems(diff, oldObj, newObj, deliveryHashMap);
       }));
-      allActions.push(flatten__default["default"](mapActionGroup('returnInfo', function () {
+      allActions.push(flatten(mapActionGroup('returnInfo', function () {
         return actionsMapReturnsInfo(diff, oldObj, newObj);
       })));
       allActions.push(mapActionGroup('custom', function () {
         return actionsMapCustom(diff, newObj, oldObj);
       }));
-      return flatten__default["default"](allActions);
+      return flatten(allActions);
     };
   }
   var orders = (function (actionGroupList, syncActionConfig) {
@@ -2183,7 +3443,7 @@
       allActions.push(mapActionGroup('base', function () {
         return actionsMapBase$f(diff, oldObj, newObj, syncActionConfig);
       }));
-      return combineValidityActions(flatten__default["default"](allActions));
+      return combineValidityActions(flatten(allActions));
     };
   }
   var productDiscounts = (function (actionGroupList) {
@@ -2252,7 +3512,7 @@
       allActions.push(mapActionGroup('custom', function () {
         return actionsMapCustom(diff, newObj, oldObj);
       }));
-      return combineValidityActions(flatten__default["default"](allActions));
+      return combineValidityActions(flatten(allActions));
     };
   }
   var discountCodes = (function (actionGroupList) {
@@ -2305,7 +3565,7 @@
       allActions.push(mapActionGroup('custom', function () {
         return actionsMapCustom(diff, newObj, oldObj);
       }));
-      return flatten__default["default"](allActions);
+      return flatten(allActions);
     };
   }
   var customerGroup = (function (actionGroupList) {
@@ -2377,7 +3637,7 @@
       allActions.push(mapActionGroup('custom', function () {
         return actionsMapCustom(diff, newObj, oldObj);
       }));
-      return combineValidityActions(flatten__default["default"](allActions));
+      return combineValidityActions(flatten(allActions));
     };
   }
   var cartDiscounts = (function (actionGroupList) {
@@ -2757,7 +4017,7 @@
       allActions.push(mapActionGroup('rates', function () {
         return actionsMapRates(diff, oldObj, newObj);
       }));
-      return flatten__default["default"](allActions);
+      return flatten(allActions);
     };
   }
   var taxCategories = (function (actionGroupList, syncActionConfig) {
@@ -2848,10 +4108,10 @@
       allActions.push(mapActionGroup('base', function () {
         return actionsMapBase$a(diff, oldObj, newObj, syncActionConfig);
       }));
-      allActions.push(flatten__default["default"](mapActionGroup('locations', function () {
+      allActions.push(flatten(mapActionGroup('locations', function () {
         return actionsMapLocations(diff, oldObj, newObj);
       })));
-      return flatten__default["default"](allActions);
+      return flatten(allActions);
     };
   }
   var zones = (function (actionGroupList, syncActionConfig) {
@@ -2967,7 +4227,7 @@
         if (diff.zoneRates[key].shippingRates) return [].concat(_toConsumableArray(actions), _toConsumableArray(actionsMapZoneRatesShippingRates(diff.zoneRates[key], oldZoneRate, newZoneRate)));
         return actions;
       }, []);
-      return flatten__default["default"](hasZoneActions ? [].concat(_toConsumableArray(shippingRateActions), [{
+      return flatten(hasZoneActions ? [].concat(_toConsumableArray(shippingRateActions), [{
         action: 'removeZone',
         zone: oldZoneRate.zone
       }, {
@@ -2984,13 +4244,13 @@
       allActions.push(mapActionGroup('base', function () {
         return actionsMapBase$9(diff, oldObj, newObj, syncActionConfig);
       }));
-      allActions.push(flatten__default["default"](mapActionGroup('zoneRates', function () {
+      allActions.push(flatten(mapActionGroup('zoneRates', function () {
         return actionsMapZoneRates(diff, oldObj, newObj);
       })));
       allActions.push(mapActionGroup('custom', function () {
         return actionsMapCustom(diff, newObj, oldObj);
       }));
-      return flatten__default["default"](allActions);
+      return flatten(allActions);
     };
   }
   var shippingMethods = (function (actionGroupList, syncActionConfig) {
@@ -3122,7 +4382,7 @@
         action: 'removeAttributeDefinition',
         name: attributeDef.previous.name
       };
-    })), _toConsumableArray(flatten__default["default"](updatedAttributeDefinitions.map(function (updatedAttributeDefinition) {
+    })), _toConsumableArray(flatten(updatedAttributeDefinitions.map(function (updatedAttributeDefinition) {
       return generateBaseFieldsUpdateActions(updatedAttributeDefinition.previous, updatedAttributeDefinition.next, {
         label: {
           action: 'changeLabel',
@@ -3172,7 +4432,7 @@
       return _objectSpread2(_objectSpread2({}, nextEnumUpdateActions), {}, _defineProperty({}, removedAttributeEnumValue.hint.attributeName, _objectSpread2(_objectSpread2({}, removedAttributeEnumValueOfSameAttributeName), {}, {
         keys: [].concat(_toConsumableArray(removedAttributeEnumValueOfSameAttributeName.keys), [removedAttributeEnumValue.previous.key])
       })));
-    }, {}))), _toConsumableArray(flatten__default["default"](updatedAttributeEnumValues.map(function (updatedAttributeEnumValue) {
+    }, {}))), _toConsumableArray(flatten(updatedAttributeEnumValues.map(function (updatedAttributeEnumValue) {
       var updateActions = generateBaseFieldsUpdateActions(updatedAttributeEnumValue.previous, updatedAttributeEnumValue.next, {
         key: {
           action: 'changeEnumKey',
@@ -3246,7 +4506,7 @@
 
   function createProductTypeMapActions(mapActionGroup, syncActionConfig) {
     return function doMapActions(diff, next, previous, options) {
-      return flatten__default["default"]([
+      return flatten([
       // we support only base fields for the product type,
       // for attributes, applying hints would be recommended
       mapActionGroup('base', function () {
@@ -3342,7 +4602,7 @@
       roleActions.push(mapActionGroup('roles', function () {
         return actionsMapRoles(diff, oldObj, newObj);
       }));
-      return flatten__default["default"]([].concat(baseActions, _toConsumableArray(groupRoleActions(roleActions))));
+      return flatten([].concat(baseActions, _toConsumableArray(groupRoleActions(roleActions))));
     };
   }
   var states = (function (actionGroupList, syncActionConfig) {
@@ -3395,7 +4655,7 @@
       allActions.push(mapActionGroup('custom', function () {
         return actionsMapCustom(diff, newObj, oldObj);
       }));
-      return flatten__default["default"](allActions);
+      return flatten(allActions);
     };
   }
   var channels = (function (actionGroupList) {
@@ -3466,7 +4726,7 @@
         var foundPreviousEnum = previous.values.find(function (previousEnum) {
           return previousEnum.key === newEnum.key;
         });
-        var isLabelEqual = isEqual__default["default"](foundPreviousEnum.label, newEnum.label);
+        var isLabelEqual = isEqual(foundPreviousEnum.label, newEnum.label);
         if (isKeyChanged) {
           // these actions is then flatten in the end
           changeActions.push({
@@ -3495,7 +4755,7 @@
     // following lists are necessary to ensure that when we change the
     // order of enumValues, we generate one updateAction instead of one at a time.
     var newEnumValuesOrder = [];
-    flatten__default["default"](buildArrayActions(attributeDiff, previous, next)).forEach(function (updateAction) {
+    flatten(buildArrayActions(attributeDiff, previous, next)).forEach(function (updateAction) {
       if (updateAction.action === changeEnumOrderActionName) {
         newEnumValuesOrder = next.values.map(function (enumValue) {
           return enumValue.key;
@@ -3510,7 +4770,7 @@
   }
   function actionsMapFieldDefinitions(fieldDefinitionsDiff, previous, next, diffPaths) {
     var actions = [];
-    forEach__default["default"](fieldDefinitionsDiff, function (diffValue, diffKey) {
+    forEach(fieldDefinitionsDiff, function (diffValue, diffKey) {
       var extractedPairs = extractMatchingPairs(diffPaths, diffKey, previous, next);
       if (getIsChangedOperation(diffKey)) {
         var _diffValue$type;
@@ -3561,7 +4821,7 @@
     // in order to prevent any eventual removal of `addAction`.
     // List of `removeActions` can be found here
     // https://docs.commercetools.com/http-api-projects-types.html#change-key
-    var sortedActions = sortBy__default["default"](actions, function (action) {
+    var sortedActions = sortBy(actions, function (action) {
       return action.action !== 'removeFieldDefinition';
     });
     return sortedActions;
@@ -3575,7 +4835,7 @@
       }), mapActionGroup('fieldDefinitions', function () {
         return actionsMapFieldDefinitions(diff.fieldDefinitions, previous.fieldDefinitions, next.fieldDefinitions, findMatchingPairs(diff.fieldDefinitions, previous.fieldDefinitions, next.fieldDefinitions, 'name'));
       }));
-      return flatten__default["default"](allActions);
+      return flatten(allActions);
     };
   }
   var types = (function (actionGroupList, syncActionConfig) {
@@ -3677,7 +4937,7 @@
       allActions.push(mapActionGroup('searchIndexingConfiguration', function () {
         return actionsMapSearchIndexingConfiguration(diff, oldObj, newObj);
       }));
-      return flatten__default["default"](allActions);
+      return flatten(allActions);
     };
   }
   var projects = (function (actionGroupList) {
@@ -3725,7 +4985,7 @@
       allActions.push(mapActionGroup('custom', function () {
         return actionsMapCustom(diff, next, previous);
       }));
-      return flatten__default["default"](allActions);
+      return flatten(allActions);
     };
   }
   var stores = (function (actionGroupList) {
@@ -3768,7 +5028,7 @@
       allActions.push(mapActionGroup('custom', function () {
         return actionsMapCustom(diff, next, previous);
       }));
-      return flatten__default["default"](allActions);
+      return flatten(allActions);
     };
   }
   var productSelections = (function (actionGroupList) {
@@ -3903,10 +5163,10 @@
       allActions.push(mapActionGroup('base', function () {
         return actionsMapBase(diff, oldObj, newObj, syncActionConfig);
       }));
-      allActions.push(flatten__default["default"](mapActionGroup('attributes', function () {
+      allActions.push(flatten(mapActionGroup('attributes', function () {
         return actionsMapAttributes(diff, oldObj, newObj);
       })));
-      return flatten__default["default"](allActions);
+      return flatten(allActions);
     };
   }
   var attributeGroups = (function (actionGroupList, syncActionConfig) {
@@ -3940,6 +5200,4 @@
   exports.createSyncTypes = types;
   exports.createSyncZones = zones;
 
-  Object.defineProperty(exports, '__esModule', { value: true });
-
 }));