object-diagram-js-differ 1.0.2 → 1.0.3

package/dist/object-diagram-js-differ.js

@@ -21,6 +21,10 @@
     return obj === undefined;
   }
 
+  function isNil(obj) {
+    return obj == null;
+  }
+
   function isArray(obj) {
     return nativeToString.call(obj) === '[object Array]';
   }
@@ -34,7 +38,7 @@
    * @return {Boolean}
    */
   function has(target, key) {
-    return nativeHasOwnProperty.call(target, key);
+    return !isNil(target) && nativeHasOwnProperty.call(target, key);
   }
 
 
@@ -104,66 +108,137 @@
     return Number(arg);
   }
 
-  class Processor {
-      constructor(options) {
-          this.selfOptions = options || {};
-          this.pipes = {};
+  function cloneRegExp(re) {
+      var _a;
+      const regexMatch = /^\/(.*)\/([gimyu]*)$/.exec(re.toString());
+      if (!regexMatch) {
+          throw new Error("Invalid RegExp");
       }
-      options(options) {
-          if (options) {
-              this.selfOptions = options;
+      return new RegExp((_a = regexMatch[1]) !== null && _a !== void 0 ? _a : "", regexMatch[2]);
+  }
+  function clone(arg) {
+      if (typeof arg !== "object") {
+          return arg;
+      }
+      if (arg === null) {
+          return null;
+      }
+      if (Array.isArray(arg)) {
+          return arg.map(clone);
+      }
+      if (arg instanceof Date) {
+          return new Date(arg.getTime());
+      }
+      if (arg instanceof RegExp) {
+          return cloneRegExp(arg);
+      }
+      const cloned = {};
+      for (const name in arg) {
+          if (Object.prototype.hasOwnProperty.call(arg, name)) {
+              cloned[name] = clone(arg[name]);
           }
-          return this.selfOptions;
       }
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      pipe(name, pipeArg) {
-          let pipe = pipeArg;
-          if (typeof name === 'string') {
-              if (typeof pipe === 'undefined') {
-                  return this.pipes[name];
-              }
-              else {
-                  this.pipes[name] = pipe;
-              }
+      return cloned;
+  }
+
+  function assertNonEmptyArray(arr, message) {
+      if (arr.length === 0) {
+          throw new Error("Expected a non-empty array");
+      }
+  }
+  /**
+   * type-safe version of `arr[arr.length - 1]`
+   * @param arr a non empty array
+   * @returns the last element of the array
+   */
+  const lastNonEmpty = (arr) => arr[arr.length - 1];
+
+  class Context {
+      setResult(result) {
+          this.result = result;
+          this.hasResult = true;
+          return this;
+      }
+      exit() {
+          this.exiting = true;
+          return this;
+      }
+      push(child, name) {
+          child.parent = this;
+          if (typeof name !== "undefined") {
+              child.childName = name;
           }
-          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;
+          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;
           }
-          pipe.processor = this;
-          return pipe;
+          else {
+              assertNonEmptyArray(this.children);
+              lastNonEmpty(this.children).next = child;
+              this.children.push(child);
+          }
+          child.next = this;
+          return this;
       }
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      process(input, pipe) {
-          let context = input;
-          context.options = this.options();
-          let nextPipe = pipe || input.pipe || 'default';
-          let 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);
+  }
+
+  class DiffContext extends Context {
+      constructor(left, right) {
+          super();
+          this.left = left;
+          this.right = right;
+          this.pipe = "diff";
+      }
+      prepareDeltaResult(result) {
+          var _a, _b, _c, _d;
+          if (typeof result === "object") {
+              if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.omitRemovedValues) &&
+                  Array.isArray(result) &&
+                  result.length > 1 &&
+                  (result.length === 2 || // modified
+                      result[2] === 0 || // deleted
+                      result[2] === 3) // moved
+              ) {
+                  // omit the left/old value (this delta will be more compact but irreversible)
+                  result[0] = 0;
               }
-              nextPipe.process(context);
-              lastPipe = nextPipe;
-              nextPipe = null;
-              if (context) {
-                  if (context.next) {
-                      context = context.next;
-                      nextPipe = context.pipe || lastPipe;
+              if ((_b = this.options) === null || _b === void 0 ? void 0 : _b.cloneDiffValues) {
+                  const clone$1 = typeof ((_c = this.options) === null || _c === void 0 ? void 0 : _c.cloneDiffValues) === "function"
+                      ? (_d = this.options) === null || _d === void 0 ? void 0 : _d.cloneDiffValues
+                      : clone;
+                  if (typeof result[0] === "object") {
+                      result[0] = clone$1(result[0]);
+                  }
+                  if (typeof result[1] === "object") {
+                      result[1] = clone$1(result[1]);
                   }
               }
           }
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-          return context.hasResult ? context.result : undefined;
+          return result;
+      }
+      setResult(result) {
+          this.prepareDeltaResult(result);
+          return super.setResult(result);
+      }
+  }
+
+  class PatchContext extends Context {
+      constructor(left, delta) {
+          super();
+          this.left = left;
+          this.delta = delta;
+          this.pipe = "patch";
+      }
+  }
+
+  class ReverseContext extends Context {
+      constructor(delta) {
+          super();
+          this.delta = delta;
+          this.pipe = "reverse";
       }
   }
 
@@ -175,18 +250,20 @@
       }
       process(input) {
           if (!this.processor) {
-              throw new Error('add this pipe to a processor before using it');
+              throw new Error("add this pipe to a processor before using it");
           }
           const debug = this.debug;
           const length = this.filters.length;
           const context = input;
           for (let index = 0; index < length; index++) {
               const filter = this.filters[index];
+              if (!filter)
+                  continue;
               if (debug) {
                   this.log(`filter: ${filter.filterName}`);
               }
               filter(context);
-              if (typeof context === 'object' && context.exiting) {
+              if (typeof context === "object" && context.exiting) {
                   context.exiting = false;
                   break;
               }
@@ -208,11 +285,11 @@
       }
       indexOf(filterName) {
           if (!filterName) {
-              throw new Error('a filter name is required');
+              throw new Error("a filter name is required");
           }
           for (let index = 0; index < this.filters.length; index++) {
               const filter = this.filters[index];
-              if (filter.filterName === filterName) {
+              if ((filter === null || filter === void 0 ? void 0 : filter.filterName) === filterName) {
                   return index;
               }
           }
@@ -248,10 +325,10 @@
       shouldHaveResult(should) {
           if (should === false) {
               this.resultCheck = null;
-              return;
+              return this;
           }
           if (this.resultCheck) {
-              return;
+              return this;
           }
           this.resultCheck = (context) => {
               if (!context.hasResult) {
@@ -265,353 +342,67 @@
       }
   }
 
-  class Context {
-      setResult(result) {
-          this.result = result;
-          this.hasResult = true;
-          return this;
-      }
-      exit() {
-          this.exiting = true;
-          return this;
-      }
-      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) {
-      const regexMatch = /^\/(.*)\/([gimyu]*)$/.exec(re.toString());
-      return new RegExp(regexMatch[1], regexMatch[2]);
-  }
-  function clone(arg) {
-      if (typeof arg !== 'object') {
-          return arg;
-      }
-      if (arg === null) {
-          return null;
-      }
-      if (Array.isArray(arg)) {
-          return arg.map(clone);
-      }
-      if (arg instanceof Date) {
-          return new Date(arg.getTime());
-      }
-      if (arg instanceof RegExp) {
-          return cloneRegExp(arg);
+  class Processor {
+      constructor(options) {
+          this.selfOptions = options || {};
+          this.pipes = {};
       }
-      const cloned = {};
-      for (const name in arg) {
-          if (Object.prototype.hasOwnProperty.call(arg, name)) {
-              cloned[name] = clone(arg[name]);
+      options(options) {
+          if (options) {
+              this.selfOptions = options;
           }
+          return this.selfOptions;
       }
-      return cloned;
-  }
-
-  class DiffContext extends Context {
-      constructor(left, right) {
-          super();
-          this.left = left;
-          this.right = right;
-          this.pipe = 'diff';
-      }
-      setResult(result) {
-          if (this.options.cloneDiffValues && typeof result === 'object') {
-              const clone$1 = typeof this.options.cloneDiffValues === 'function'
-                  ? this.options.cloneDiffValues
-                  : clone;
-              if (typeof result[0] === 'object') {
-                  result[0] = clone$1(result[0]);
-              }
-              if (typeof result[1] === 'object') {
-                  result[1] = clone$1(result[1]);
+      pipe(name, pipeArg) {
+          let pipe = pipeArg;
+          if (typeof name === "string") {
+              if (typeof pipe === "undefined") {
+                  return this.pipes[name];
               }
+              this.pipes[name] = pipe;
           }
-          return super.setResult(result);
-      }
-  }
-
-  class PatchContext extends Context {
-      constructor(left, delta) {
-          super();
-          this.left = left;
-          this.delta = delta;
-          this.pipe = 'patch';
-      }
-  }
-
-  class ReverseContext extends Context {
-      constructor(delta) {
-          super();
-          this.delta = delta;
-          this.pipe = 'reverse';
-      }
-  }
-
-  const 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';
-  const 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;
-      }
-      const nonNestedDelta = context.delta;
-      if (nonNestedDelta.length === 1) {
-          context.setResult(nonNestedDelta[0]).exit();
-          return;
-      }
-      if (nonNestedDelta.length === 2) {
-          if (context.left instanceof RegExp) {
-              const regexArgs = /^\/(.*)\/([gimyu]+)$/.exec(nonNestedDelta[1]);
-              if (regexArgs) {
-                  context.setResult(new RegExp(regexArgs[1], regexArgs[2])).exit();
-                  return;
+          if (name && name.name) {
+              pipe = name;
+              if (pipe.processor === this) {
+                  return pipe;
               }
+              this.pipes[pipe.name] = pipe;
           }
-          context.setResult(nonNestedDelta[1]).exit();
-          return;
-      }
-      if (nonNestedDelta.length === 3 && nonNestedDelta[2] === 0) {
-          context.setResult(undefined).exit();
-      }
-  };
-  patchFilter$3.filterName = 'trivial';
-  const 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;
-      }
-      const 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';
-
-  const collectChildrenDiffFilter = (context) => {
-      if (!context || !context.children) {
-          return;
-      }
-      const length = context.children.length;
-      let child;
-      let result = context.result;
-      for (let 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';
-  const objectsDiffFilter = (context) => {
-      if (context.leftIsArray || context.leftType !== 'object') {
-          return;
-      }
-      const left = context.left;
-      const right = context.right;
-      let name;
-      let child;
-      const 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';
-  const patchFilter$2 = function nestedPatchFilter(context) {
-      if (!context.nested) {
-          return;
-      }
-      const nestedDelta = context.delta;
-      if (nestedDelta._t) {
-          return;
-      }
-      const objectDelta = nestedDelta;
-      let name;
-      let child;
-      for (name in objectDelta) {
-          child = new PatchContext(context.left[name], objectDelta[name]);
-          context.push(child, name);
-      }
-      context.exit();
-  };
-  patchFilter$2.filterName = 'objects';
-  const collectChildrenPatchFilter$1 = function collectChildrenPatchFilter(context) {
-      if (!context || !context.children) {
-          return;
-      }
-      const deltaWithChildren = context.delta;
-      if (deltaWithChildren._t) {
-          return;
-      }
-      const object = context.left;
-      const length = context.children.length;
-      let child;
-      for (let index = 0; index < length; index++) {
-          child = context.children[index];
-          const 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;
+          if (!pipe) {
+              throw new Error(`pipe is not defined: ${name}`);
           }
-      }
-      context.setResult(object).exit();
-  };
-  collectChildrenPatchFilter$1.filterName = 'collectChildren';
-  const reverseFilter$2 = function nestedReverseFilter(context) {
-      if (!context.nested) {
-          return;
-      }
-      const nestedDelta = context.delta;
-      if (nestedDelta._t) {
-          return;
-      }
-      const objectDelta = context.delta;
-      let name;
-      let child;
-      for (name in objectDelta) {
-          child = new ReverseContext(objectDelta[name]);
-          context.push(child, name);
-      }
-      context.exit();
-  };
-  reverseFilter$2.filterName = 'objects';
-  const collectChildrenReverseFilter$1 = (context) => {
-      if (!context || !context.children) {
-          return;
-      }
-      const deltaWithChildren = context.delta;
-      if (deltaWithChildren._t) {
-          return;
-      }
-      const length = context.children.length;
-      let child;
-      const delta = {};
-      for (let index = 0; index < length; index++) {
-          child = context.children[index];
-          const property = child.childName;
-          if (delta[property] !== child.result) {
-              delta[property] = child.result;
+          pipe.processor = this;
+          return pipe;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      process(input, pipe) {
+          let context = input;
+          context.options = this.options();
+          let nextPipe = pipe || input.pipe || "default";
+          let lastPipe = undefined;
+          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;
       }
-      context.setResult(delta).exit();
-  };
-  collectChildrenReverseFilter$1.filterName = 'collectChildren';
+  }
 
   /*
 
@@ -620,36 +411,45 @@
   reference: http://en.wikipedia.org/wiki/Longest_common_subsequence_problem
 
   */
-  const defaultMatch = function (array1, array2, index1, index2) {
-      return array1[index1] === array2[index2];
-  };
-  const lengthMatrix = function (array1, array2, match, context) {
+  const defaultMatch = (array1, array2, index1, index2) => array1[index1] === array2[index2];
+  const lengthMatrix = (array1, array2, match, context) => {
+      var _a, _b, _c;
       const len1 = array1.length;
       const len2 = array2.length;
-      let x, y;
+      let x;
+      let y;
       // initialize empty matrix of len1+1 x len2+1
       const matrix = new Array(len1 + 1);
       for (x = 0; x < len1 + 1; x++) {
-          matrix[x] = new Array(len2 + 1);
+          const matrixNewRow = new Array(len2 + 1);
           for (y = 0; y < len2 + 1; y++) {
-              matrix[x][y] = 0;
+              matrixNewRow[y] = 0;
           }
+          matrix[x] = matrixNewRow;
       }
       matrix.match = match;
       // save sequence lengths for each coordinate
       for (x = 1; x < len1 + 1; x++) {
+          const matrixRowX = matrix[x];
+          if (matrixRowX === undefined) {
+              throw new Error("LCS matrix row is undefined");
+          }
+          const matrixRowBeforeX = matrix[x - 1];
+          if (matrixRowBeforeX === undefined) {
+              throw new Error("LCS matrix row is undefined");
+          }
           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;
+                  matrixRowX[y] = ((_a = matrixRowBeforeX[y - 1]) !== null && _a !== void 0 ? _a : 0) + 1;
               }
               else {
-                  matrix[x][y] = Math.max(matrix[x - 1][y], matrix[x][y - 1]);
+                  matrixRowX[y] = Math.max((_b = matrixRowBeforeX[y]) !== null && _b !== void 0 ? _b : 0, (_c = matrixRowX[y - 1]) !== null && _c !== void 0 ? _c : 0);
               }
           }
       }
       return matrix;
   };
-  const backtrack = function (matrix, array1, array2, context) {
+  const backtrack = (matrix, array1, array2, context) => {
       let index1 = array1.length;
       let index2 = array2.length;
       const subsequence = {
@@ -658,6 +458,9 @@
           indices2: [],
       };
       while (index1 !== 0 && index2 !== 0) {
+          if (matrix.match === undefined) {
+              throw new Error("LCS matrix match function is undefined");
+          }
           const sameLetter = matrix.match(array1, array2, index1 - 1, index2 - 1, context);
           if (sameLetter) {
               subsequence.sequence.unshift(array1[index1 - 1]);
@@ -667,8 +470,22 @@
               --index2;
           }
           else {
-              const valueAtMatrixAbove = matrix[index1][index2 - 1];
-              const valueAtMatrixLeft = matrix[index1 - 1][index2];
+              const matrixRowIndex1 = matrix[index1];
+              if (matrixRowIndex1 === undefined) {
+                  throw new Error("LCS matrix row is undefined");
+              }
+              const valueAtMatrixAbove = matrixRowIndex1[index2 - 1];
+              if (valueAtMatrixAbove === undefined) {
+                  throw new Error("LCS matrix value is undefined");
+              }
+              const matrixRowBeforeIndex1 = matrix[index1 - 1];
+              if (matrixRowBeforeIndex1 === undefined) {
+                  throw new Error("LCS matrix row is undefined");
+              }
+              const valueAtMatrixLeft = matrixRowBeforeIndex1[index2];
+              if (valueAtMatrixLeft === undefined) {
+                  throw new Error("LCS matrix value is undefined");
+              }
               if (valueAtMatrixAbove > valueAtMatrixLeft) {
                   --index2;
               }
@@ -679,7 +496,7 @@
       }
       return subsequence;
   };
-  const get = function (array1, array2, match, context) {
+  const get = (array1, array2, match, context) => {
       const innerContext = context || {};
       const matrix = lengthMatrix(array1, array2, match || defaultMatch, innerContext);
       return backtrack(matrix, array1, array2, innerContext);
@@ -699,6 +516,7 @@
               }
           }
       }
+      return false;
   }
   function matchItems(array1, array2, index1, index2, context) {
       const value1 = array1[index1];
@@ -706,7 +524,7 @@
       if (value1 === value2) {
           return true;
       }
-      if (typeof value1 !== 'object' || typeof value2 !== 'object') {
+      if (typeof value1 !== "object" || typeof value2 !== "object") {
           return false;
       }
       const objectHash = context.objectHash;
@@ -716,29 +534,30 @@
       }
       context.hashCache1 = context.hashCache1 || [];
       let hash1 = context.hashCache1[index1];
-      if (typeof hash1 === 'undefined') {
+      if (typeof hash1 === "undefined") {
           context.hashCache1[index1] = hash1 = objectHash(value1, index1);
       }
-      if (typeof hash1 === 'undefined') {
+      if (typeof hash1 === "undefined") {
           return false;
       }
       context.hashCache2 = context.hashCache2 || [];
       let hash2 = context.hashCache2[index2];
-      if (typeof hash2 === 'undefined') {
+      if (typeof hash2 === "undefined") {
           context.hashCache2[index2] = hash2 = objectHash(value2, index2);
       }
-      if (typeof hash2 === 'undefined') {
+      if (typeof hash2 === "undefined") {
           return false;
       }
       return hash1 === hash2;
   }
-  const diffFilter$2 = function arraysDiffFilter(context) {
+  const diffFilter$3 = function arraysDiffFilter(context) {
+      var _a, _b, _c, _d, _e;
       if (!context.leftIsArray) {
           return;
       }
       const matchContext = {
-          objectHash: context.options && context.options.objectHash,
-          matchByPosition: context.options && context.options.matchByPosition,
+          objectHash: (_a = context.options) === null || _a === void 0 ? void 0 : _a.objectHash,
+          matchByPosition: (_b = context.options) === null || _b === void 0 ? void 0 : _b.matchByPosition,
       };
       let commonHead = 0;
       let commonTail = 0;
@@ -753,7 +572,7 @@
       if (len1 > 0 &&
           len2 > 0 &&
           !matchContext.objectHash &&
-          typeof matchContext.matchByPosition !== 'boolean') {
+          typeof matchContext.matchByPosition !== "boolean") {
           matchContext.matchByPosition = !arraysHaveMatchByRef(array1, array2, len1, len2);
       }
       // separate common head
@@ -784,10 +603,11 @@
           }
           // trivial case, a block (1 or more consecutive items) was added
           result = result || {
-              _t: 'a',
+              _t: "a",
           };
           for (index = commonHead; index < len2 - commonTail; index++) {
               result[index] = [array2[index]];
+              context.prepareDeltaResult(result[index]);
           }
           context.setResult(result).exit();
           return;
@@ -795,42 +615,42 @@
       if (commonHead + commonTail === len2) {
           // trivial case, a block (1 or more consecutive items) was removed
           result = result || {
-              _t: 'a',
+              _t: "a",
           };
           for (index = commonHead; index < len1 - commonTail; index++) {
-              result[`_${index}`] = [array1[index], 0, 0];
+              const key = `_${index}`;
+              result[key] = [array1[index], 0, 0];
+              context.prepareDeltaResult(result[key]);
           }
           context.setResult(result).exit();
           return;
       }
       // reset hash cache
-      delete matchContext.hashCache1;
-      delete matchContext.hashCache2;
+      matchContext.hashCache1 = undefined;
+      matchContext.hashCache2 = undefined;
       // diff is not trivial, find the LCS (Longest Common Subsequence)
       const trimmed1 = array1.slice(commonHead, len1 - commonTail);
       const trimmed2 = array2.slice(commonHead, len2 - commonTail);
       const seq = lcs.get(trimmed1, trimmed2, matchItems, matchContext);
       const removedItems = [];
       result = result || {
-          _t: 'a',
+          _t: "a",
       };
       for (index = commonHead; index < len1 - commonTail; index++) {
           if (seq.indices1.indexOf(index - commonHead) < 0) {
               // removed
-              result[`_${index}`] = [array1[index], 0, 0];
+              const key = `_${index}`;
+              result[key] = [array1[index], 0, 0];
+              context.prepareDeltaResult(result[key]);
               removedItems.push(index);
           }
       }
       let detectMove = true;
-      if (context.options &&
-          context.options.arrays &&
-          context.options.arrays.detectMove === false) {
+      if (((_c = context.options) === null || _c === void 0 ? void 0 : _c.arrays) && context.options.arrays.detectMove === false) {
           detectMove = false;
       }
       let includeValueOnMove = false;
-      if (context.options &&
-          context.options.arrays &&
-          context.options.arrays.includeValueOnMove) {
+      if ((_e = (_d = context.options) === null || _d === void 0 ? void 0 : _d.arrays) === null || _e === void 0 ? void 0 : _e.includeValueOnMove) {
           includeValueOnMove = true;
       }
       const removedItemsLength = removedItems.length;
@@ -842,12 +662,16 @@
               if (detectMove && removedItemsLength > 0) {
                   for (let removeItemIndex1 = 0; removeItemIndex1 < removedItemsLength; removeItemIndex1++) {
                       index1 = removedItems[removeItemIndex1];
-                      if (matchItems(trimmed1, trimmed2, index1 - commonHead, index - commonHead, matchContext)) {
+                      const resultItem = index1 === undefined ? undefined : result[`_${index1}`];
+                      if (index1 !== undefined &&
+                          resultItem &&
+                          matchItems(trimmed1, trimmed2, index1 - commonHead, index - commonHead, matchContext)) {
                           // store position move as: [originalValue, newPosition, ARRAY_MOVE]
-                          result[`_${index1}`].splice(1, 2, index, ARRAY_MOVE);
+                          resultItem.splice(1, 2, index, ARRAY_MOVE);
+                          resultItem.splice(1, 2, index, ARRAY_MOVE);
                           if (!includeValueOnMove) {
                               // don't include moved value on diff, to save bytes
-                              result[`_${index1}`][0] = '';
+                              resultItem[0] = "";
                           }
                           index2 = index;
                           child = new DiffContext(array1[index1], array2[index2]);
@@ -861,11 +685,18 @@
               if (!isMove) {
                   // added
                   result[index] = [array2[index]];
+                  context.prepareDeltaResult(result[index]);
               }
           }
           else {
               // match, do inner diff
+              if (seq.indices1[indexOnArray2] === undefined) {
+                  throw new Error(`Invalid indexOnArray2: ${indexOnArray2}, seq.indices1: ${seq.indices1}`);
+              }
               index1 = seq.indices1[indexOnArray2] + commonHead;
+              if (seq.indices2[indexOnArray2] === undefined) {
+                  throw new Error(`Invalid indexOnArray2: ${indexOnArray2}, seq.indices2: ${seq.indices2}`);
+              }
               index2 = seq.indices2[indexOnArray2] + commonHead;
               child = new DiffContext(array1[index1], array2[index2]);
               context.push(child, index2);
@@ -873,7 +704,7 @@
       }
       context.setResult(result).exit();
   };
-  diffFilter$2.filterName = 'arrays';
+  diffFilter$3.filterName = "arrays";
   const compare = {
       numerically(a, b) {
           return a - b;
@@ -882,12 +713,13 @@
           return (a, b) => a[name] - b[name];
       },
   };
-  const patchFilter$1 = function nestedPatchFilter(context) {
+  const patchFilter$3 = function nestedPatchFilter(context) {
+      var _a;
       if (!context.nested) {
           return;
       }
       const nestedDelta = context.delta;
-      if (nestedDelta._t !== 'a') {
+      if (nestedDelta._t !== "a") {
           return;
       }
       let index;
@@ -899,17 +731,17 @@
       let toInsert = [];
       const toModify = [];
       for (index in delta) {
-          if (index !== '_t') {
-              if (index[0] === '_') {
+          if (index !== "_t") {
+              if (index[0] === "_") {
                   const removedOrMovedIndex = index;
                   // removed item from original array
-                  if (delta[removedOrMovedIndex][2] === 0 ||
-                      delta[removedOrMovedIndex][2] === ARRAY_MOVE) {
-                      toRemove.push(parseInt(index.slice(1), 10));
+                  if (delta[removedOrMovedIndex] !== undefined &&
+                      (delta[removedOrMovedIndex][2] === 0 ||
+                          delta[removedOrMovedIndex][2] === ARRAY_MOVE)) {
+                      toRemove.push(Number.parseInt(index.slice(1), 10));
                   }
                   else {
-                      throw new Error('only removal or move can be applied at original array indices,' +
-                          ` invalid diff type: ${delta[removedOrMovedIndex][2]}`);
+                      throw new Error(`only removal or move can be applied at original array indices, invalid diff type: ${(_a = delta[removedOrMovedIndex]) === null || _a === void 0 ? void 0 : _a[2]}`);
                   }
               }
               else {
@@ -917,14 +749,14 @@
                   if (delta[numberIndex].length === 1) {
                       // added item at new array
                       toInsert.push({
-                          index: parseInt(numberIndex, 10),
+                          index: Number.parseInt(numberIndex, 10),
                           value: delta[numberIndex][0],
                       });
                   }
                   else {
                       // modified item at new array
                       toModify.push({
-                          index: parseInt(numberIndex, 10),
+                          index: Number.parseInt(numberIndex, 10),
                           delta: delta[numberIndex],
                       });
                   }
@@ -935,9 +767,11 @@
       toRemove = toRemove.sort(compare.numerically);
       for (index = toRemove.length - 1; index >= 0; index--) {
           index1 = toRemove[index];
+          if (index1 === undefined)
+              continue;
           const indexDiff = delta[`_${index1}`];
           const removedValue = array.splice(index1, 1)[0];
-          if (indexDiff[2] === ARRAY_MOVE) {
+          if ((indexDiff === null || indexDiff === void 0 ? void 0 : indexDiff[2]) === ARRAY_MOVE) {
               // reinsert later
               toInsert.push({
                   index: indexDiff[1],
@@ -946,19 +780,22 @@
           }
       }
       // insert items, in reverse order to avoid moving our own floor
-      toInsert = toInsert.sort(compare.numericallyBy('index'));
+      toInsert = toInsert.sort(compare.numericallyBy("index"));
       const toInsertLength = toInsert.length;
       for (index = 0; index < toInsertLength; index++) {
           const insertion = toInsert[index];
+          if (insertion === undefined)
+              continue;
           array.splice(insertion.index, 0, insertion.value);
       }
       // apply modifications
       const toModifyLength = toModify.length;
-      let child;
       if (toModifyLength > 0) {
           for (index = 0; index < toModifyLength; index++) {
               const modification = toModify[index];
-              child = new PatchContext(array[modification.index], modification.delta);
+              if (modification === undefined)
+                  continue;
+              const child = new PatchContext(array[modification.index], modification.delta);
               context.push(child, modification.index);
           }
       }
@@ -968,27 +805,28 @@
       }
       context.exit();
   };
-  patchFilter$1.filterName = 'arrays';
-  const collectChildrenPatchFilter = function collectChildrenPatchFilter(context) {
+  patchFilter$3.filterName = "arrays";
+  const collectChildrenPatchFilter$1 = function collectChildrenPatchFilter(context) {
       if (!context || !context.children) {
           return;
       }
       const deltaWithChildren = context.delta;
-      if (deltaWithChildren._t !== 'a') {
+      if (deltaWithChildren._t !== "a") {
           return;
       }
       const array = context.left;
       const length = context.children.length;
-      let child;
       for (let index = 0; index < length; index++) {
-          child = context.children[index];
+          const child = context.children[index];
+          if (child === undefined)
+              continue;
           const arrayIndex = child.childName;
           array[arrayIndex] = child.result;
       }
       context.setResult(array).exit();
   };
-  collectChildrenPatchFilter.filterName = 'arraysCollectChildren';
-  const reverseFilter$1 = function arraysReverseFilter(context) {
+  collectChildrenPatchFilter$1.filterName = "arraysCollectChildren";
+  const reverseFilter$3 = function arraysReverseFilter(context) {
       if (!context.nested) {
           const nonNestedDelta = context.delta;
           if (nonNestedDelta[2] === ARRAY_MOVE) {
@@ -997,7 +835,7 @@
               context
                   .setResult([
                   arrayMoveDelta[0],
-                  parseInt(context.childName.substring(1), 10),
+                  Number.parseInt(context.childName.substring(1), 10),
                   ARRAY_MOVE,
               ])
                   .exit();
@@ -1005,27 +843,25 @@
           return;
       }
       const nestedDelta = context.delta;
-      if (nestedDelta._t !== 'a') {
+      if (nestedDelta._t !== "a") {
           return;
       }
       const arrayDelta = nestedDelta;
-      let name;
-      let child;
-      for (name in arrayDelta) {
-          if (name === '_t') {
+      for (const name in arrayDelta) {
+          if (name === "_t") {
               continue;
           }
-          child = new ReverseContext(arrayDelta[name]);
+          const child = new ReverseContext(arrayDelta[name]);
           context.push(child, name);
       }
       context.exit();
   };
-  reverseFilter$1.filterName = 'arrays';
+  reverseFilter$3.filterName = "arrays";
   const reverseArrayDeltaIndex = (delta, index, itemDelta) => {
-      if (typeof index === 'string' && index[0] === '_') {
-          return parseInt(index.substring(1), 10);
+      if (typeof index === "string" && index[0] === "_") {
+          return Number.parseInt(index.substring(1), 10);
       }
-      else if (Array.isArray(itemDelta) && itemDelta[2] === 0) {
+      if (Array.isArray(itemDelta) && itemDelta[2] === 0) {
           return `_${index}`;
       }
       let reverseIndex = +index;
@@ -1033,7 +869,7 @@
           const deltaItem = delta[deltaIndex];
           if (Array.isArray(deltaItem)) {
               if (deltaItem[2] === ARRAY_MOVE) {
-                  const moveFromIndex = parseInt(deltaIndex.substring(1), 10);
+                  const moveFromIndex = Number.parseInt(deltaIndex.substring(1), 10);
                   const moveToIndex = deltaItem[1];
                   if (moveToIndex === +index) {
                       return moveFromIndex;
@@ -1047,37 +883,41 @@
                   }
               }
               else if (deltaItem[2] === 0) {
-                  const deleteIndex = parseInt(deltaIndex.substring(1), 10);
+                  const deleteIndex = Number.parseInt(deltaIndex.substring(1), 10);
                   if (deleteIndex <= reverseIndex) {
                       reverseIndex++;
                   }
               }
               else if (deltaItem.length === 1 &&
-                  parseInt(deltaIndex, 10) <= reverseIndex) {
+                  Number.parseInt(deltaIndex, 10) <= reverseIndex) {
                   reverseIndex--;
               }
           }
       }
       return reverseIndex;
   };
-  const collectChildrenReverseFilter = (context) => {
+  const collectChildrenReverseFilter$1 = (context) => {
       if (!context || !context.children) {
           return;
       }
       const deltaWithChildren = context.delta;
-      if (deltaWithChildren._t !== 'a') {
+      if (deltaWithChildren._t !== "a") {
           return;
       }
       const arrayDelta = deltaWithChildren;
       const length = context.children.length;
-      let child;
       const delta = {
-          _t: 'a',
+          _t: "a",
       };
       for (let index = 0; index < length; index++) {
-          child = context.children[index];
+          const child = context.children[index];
+          if (child === undefined)
+              continue;
           let name = child.newName;
-          if (typeof name === 'undefined') {
+          if (typeof name === "undefined") {
+              if (child.childName === undefined) {
+                  throw new Error("child.childName is undefined");
+              }
               name = reverseArrayDeltaIndex(arrayDelta, child.childName, child.result);
           }
           if (delta[name] !== child.result) {
@@ -1087,9 +927,9 @@
       }
       context.setResult(delta).exit();
   };
-  collectChildrenReverseFilter.filterName = 'arraysCollectChildren';
+  collectChildrenReverseFilter$1.filterName = "arraysCollectChildren";
 
-  const diffFilter$1 = function datesDiffFilter(context) {
+  const diffFilter$2 = function datesDiffFilter(context) {
       if (context.left instanceof Date) {
           if (context.right instanceof Date) {
               if (context.left.getTime() !== context.right.getTime()) {
@@ -1108,7 +948,150 @@
           context.setResult([context.left, context.right]).exit();
       }
   };
-  diffFilter$1.filterName = 'dates';
+  diffFilter$2.filterName = "dates";
+
+  const collectChildrenDiffFilter = (context) => {
+      if (!context || !context.children) {
+          return;
+      }
+      const length = context.children.length;
+      let result = context.result;
+      for (let index = 0; index < length; index++) {
+          const child = context.children[index];
+          if (child === undefined)
+              continue;
+          if (typeof child.result === "undefined") {
+              continue;
+          }
+          result = result || {};
+          if (child.childName === undefined) {
+              throw new Error("diff child.childName is undefined");
+          }
+          result[child.childName] = child.result;
+      }
+      if (result && context.leftIsArray) {
+          result._t = "a";
+      }
+      context.setResult(result).exit();
+  };
+  collectChildrenDiffFilter.filterName = "collectChildren";
+  const objectsDiffFilter = (context) => {
+      var _a;
+      if (context.leftIsArray || context.leftType !== "object") {
+          return;
+      }
+      const left = context.left;
+      const right = context.right;
+      const propertyFilter = (_a = context.options) === null || _a === void 0 ? void 0 : _a.propertyFilter;
+      for (const name in left) {
+          if (!Object.prototype.hasOwnProperty.call(left, name)) {
+              continue;
+          }
+          if (propertyFilter && !propertyFilter(name, context)) {
+              continue;
+          }
+          const child = new DiffContext(left[name], right[name]);
+          context.push(child, name);
+      }
+      for (const name in right) {
+          if (!Object.prototype.hasOwnProperty.call(right, name)) {
+              continue;
+          }
+          if (propertyFilter && !propertyFilter(name, context)) {
+              continue;
+          }
+          if (typeof left[name] === "undefined") {
+              const 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";
+  const patchFilter$2 = function nestedPatchFilter(context) {
+      if (!context.nested) {
+          return;
+      }
+      const nestedDelta = context.delta;
+      if (nestedDelta._t) {
+          return;
+      }
+      const objectDelta = nestedDelta;
+      for (const name in objectDelta) {
+          const child = new PatchContext(context.left[name], objectDelta[name]);
+          context.push(child, name);
+      }
+      context.exit();
+  };
+  patchFilter$2.filterName = "objects";
+  const collectChildrenPatchFilter = function collectChildrenPatchFilter(context) {
+      if (!context || !context.children) {
+          return;
+      }
+      const deltaWithChildren = context.delta;
+      if (deltaWithChildren._t) {
+          return;
+      }
+      const object = context.left;
+      const length = context.children.length;
+      for (let index = 0; index < length; index++) {
+          const child = context.children[index];
+          if (child === undefined)
+              continue;
+          const 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.filterName = "collectChildren";
+  const reverseFilter$2 = function nestedReverseFilter(context) {
+      if (!context.nested) {
+          return;
+      }
+      const nestedDelta = context.delta;
+      if (nestedDelta._t) {
+          return;
+      }
+      const objectDelta = context.delta;
+      for (const name in objectDelta) {
+          const child = new ReverseContext(objectDelta[name]);
+          context.push(child, name);
+      }
+      context.exit();
+  };
+  reverseFilter$2.filterName = "objects";
+  const collectChildrenReverseFilter = (context) => {
+      if (!context || !context.children) {
+          return;
+      }
+      const deltaWithChildren = context.delta;
+      if (deltaWithChildren._t) {
+          return;
+      }
+      const length = context.children.length;
+      const delta = {};
+      for (let index = 0; index < length; index++) {
+          const child = context.children[index];
+          if (child === undefined)
+              continue;
+          const property = child.childName;
+          if (delta[property] !== child.result) {
+              delta[property] = child.result;
+          }
+      }
+      context.setResult(delta).exit();
+  };
+  collectChildrenReverseFilter.filterName = "collectChildren";
 
   const TEXT_DIFF = 2;
   const DEFAULT_MIN_LENGTH = 60;
@@ -1124,21 +1107,20 @@
               if (!required) {
                   return null;
               }
-              const 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.');
+              const 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 (txt1, txt2) {
-                  return instance.patch_toText(instance.patch_make(txt1, txt2));
-              },
-              patch: function (txt1, patch) {
+              diff: (txt1, txt2) => instance.patch_toText(instance.patch_make(txt1, txt2)),
+              patch: (txt1, patch) => {
                   const results = instance.patch_apply(instance.patch_fromText(patch), txt1);
-                  for (let i = 0; i < results[1].length; i++) {
-                      if (!results[1][i]) {
-                          const error = new Error('text patch failed');
+                  for (const resultOk of results[1]) {
+                      if (!resultOk) {
+                          const error = new Error("text patch failed");
                           error.textPatchFailed = true;
+                          throw error;
                       }
                   }
                   return results[0];
@@ -1147,16 +1129,14 @@
       }
       return cachedDiffPatch;
   }
-  const diffFilter = function textsDiffFilter(context) {
-      if (context.leftType !== 'string') {
+  const diffFilter$1 = function textsDiffFilter(context) {
+      var _a, _b;
+      if (context.leftType !== "string") {
           return;
       }
       const left = context.left;
       const right = context.right;
-      const minLength = (context.options &&
-          context.options.textDiff &&
-          context.options.textDiff.minLength) ||
-          DEFAULT_MIN_LENGTH;
+      const minLength = ((_b = (_a = context.options) === null || _a === void 0 ? void 0 : _a.textDiff) === null || _b === void 0 ? void 0 : _b.minLength) || DEFAULT_MIN_LENGTH;
       if (left.length < minLength || right.length < minLength) {
           context.setResult([left, right]).exit();
           return;
@@ -1172,8 +1152,8 @@
       const diff = diffMatchPatch.diff;
       context.setResult([diff(left, right), 0, TEXT_DIFF]).exit();
   };
-  diffFilter.filterName = 'texts';
-  const patchFilter = function textsPatchFilter(context) {
+  diffFilter$1.filterName = "texts";
+  const patchFilter$1 = function textsPatchFilter(context) {
       if (context.nested) {
           return;
       }
@@ -1186,50 +1166,41 @@
       const patch = getDiffMatchPatch(context.options, true).patch;
       context.setResult(patch(context.left, textDiffDelta[0])).exit();
   };
-  patchFilter.filterName = 'texts';
-  const textDeltaReverse = function (delta) {
-      let i;
-      let l;
-      let line;
-      let lineTmp;
-      let header = null;
+  patchFilter$1.filterName = "texts";
+  const textDeltaReverse = (delta) => {
+      var _a, _b, _c;
       const headerRegex = /^@@ +-(\d+),(\d+) +\+(\d+),(\d+) +@@$/;
-      let lineHeader;
-      const lines = delta.split('\n');
-      for (i = 0, l = lines.length; i < l; i++) {
-          line = lines[i];
+      const lines = delta.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          if (line === undefined)
+              continue;
           const 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] +
-                      ' @@';
+          if (lineStart === "@") {
+              const header = headerRegex.exec(line);
+              if (header !== null) {
+                  const 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) === '+') {
+          else if (lineStart === "+") {
+              lines[i] = `-${(_a = lines[i]) === null || _a === void 0 ? void 0 : _a.slice(1)}`;
+              if (((_b = lines[i - 1]) === null || _b === void 0 ? void 0 : _b.slice(0, 1)) === "+") {
                   // swap lines to keep default order (-+)
-                  lineTmp = lines[i];
+                  const lineTmp = lines[i];
                   lines[i] = lines[i - 1];
                   lines[i - 1] = lineTmp;
               }
           }
-          else if (lineStart === '-') {
-              lines[i] = '+' + lines[i].slice(1);
+          else if (lineStart === "-") {
+              lines[i] = `+${(_c = lines[i]) === null || _c === void 0 ? void 0 : _c.slice(1)}`;
           }
       }
-      return lines.join('\n');
+      return lines.join("\n");
   };
-  const reverseFilter = function textsReverseFilter(context) {
+  const reverseFilter$1 = function textsReverseFilter(context) {
       if (context.nested) {
           return;
       }
@@ -1243,19 +1214,125 @@
           .setResult([textDeltaReverse(textDiffDelta[0]), 0, TEXT_DIFF])
           .exit();
   };
-  reverseFilter.filterName = 'texts';
+  reverseFilter$1.filterName = "texts";
+
+  const diffFilter = 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.filterName = "trivial";
+  const patchFilter = function trivialMatchesPatchFilter(context) {
+      if (typeof context.delta === "undefined") {
+          context.setResult(context.left).exit();
+          return;
+      }
+      context.nested = !Array.isArray(context.delta);
+      if (context.nested) {
+          return;
+      }
+      const nonNestedDelta = context.delta;
+      if (nonNestedDelta.length === 1) {
+          context.setResult(nonNestedDelta[0]).exit();
+          return;
+      }
+      if (nonNestedDelta.length === 2) {
+          if (context.left instanceof RegExp) {
+              const regexArgs = /^\/(.*)\/([gimyu]+)$/.exec(nonNestedDelta[1]);
+              if (regexArgs === null || regexArgs === void 0 ? void 0 : regexArgs[1]) {
+                  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.filterName = "trivial";
+  const reverseFilter = function trivialReferseFilter(context) {
+      if (typeof context.delta === "undefined") {
+          context.setResult(context.delta).exit();
+          return;
+      }
+      context.nested = !Array.isArray(context.delta);
+      if (context.nested) {
+          return;
+      }
+      const 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.filterName = "trivial";
 
   class DiffPatcher {
       constructor(options) {
           this.processor = new Processor(options);
-          this.processor.pipe(new Pipe('diff')
-              .append(collectChildrenDiffFilter, diffFilter$3, diffFilter$1, diffFilter, objectsDiffFilter, diffFilter$2)
+          this.processor.pipe(new Pipe("diff")
+              .append(collectChildrenDiffFilter, diffFilter, diffFilter$2, diffFilter$1, objectsDiffFilter, diffFilter$3)
               .shouldHaveResult());
-          this.processor.pipe(new Pipe('patch')
-              .append(collectChildrenPatchFilter$1, collectChildrenPatchFilter, patchFilter$3, patchFilter, patchFilter$2, patchFilter$1)
+          this.processor.pipe(new Pipe("patch")
+              .append(collectChildrenPatchFilter, collectChildrenPatchFilter$1, patchFilter, patchFilter$1, patchFilter$2, patchFilter$3)
               .shouldHaveResult());
-          this.processor.pipe(new Pipe('reverse')
-              .append(collectChildrenReverseFilter$1, collectChildrenReverseFilter, reverseFilter$3, reverseFilter, reverseFilter$2, reverseFilter$1)
+          this.processor.pipe(new Pipe("reverse")
+              .append(collectChildrenReverseFilter, collectChildrenReverseFilter$1, reverseFilter, reverseFilter$1, reverseFilter$2, reverseFilter$3)
               .shouldHaveResult());
       }
       options(options) {