object-diagram-js-differ 1.0.1 → 1.0.2

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

@@ -0,0 +1,1465 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.odDiff = factory());
+})(this, (function () { 'use strict';
+
+  /**
+   * Flatten array, one level deep.
+   *
+   * @template T
+   *
+   * @param {T[][] | T[] | null} [arr]
+   *
+   * @return {T[]}
+   */
+
+  const nativeToString = Object.prototype.toString;
+  const nativeHasOwnProperty = Object.prototype.hasOwnProperty;
+
+  function isUndefined(obj) {
+    return obj === undefined;
+  }
+
+  function isArray(obj) {
+    return nativeToString.call(obj) === '[object Array]';
+  }
+
+  /**
+   * Return true, if target owns a property with the given key.
+   *
+   * @param {Object} target
+   * @param {String} key
+   *
+   * @return {Boolean}
+   */
+  function has(target, key) {
+    return nativeHasOwnProperty.call(target, key);
+  }
+
+
+  /**
+   * Iterate over collection; returning something
+   * (non-undefined) will stop iteration.
+   *
+   * @template T
+   * @param {Collection<T>} collection
+   * @param { ((item: T, idx: number) => (boolean|void)) | ((item: T, key: string) => (boolean|void)) } iterator
+   *
+   * @return {T} return result that stopped the iteration
+   */
+  function forEach(collection, iterator) {
+
+    let val,
+        result;
+
+    if (isUndefined(collection)) {
+      return;
+    }
+
+    const convertKey = isArray(collection) ? toNum : identity;
+
+    for (let key in collection) {
+
+      if (has(collection, key)) {
+        val = collection[key];
+
+        result = iterator(val, convertKey(key));
+
+        if (result === false) {
+          return val;
+        }
+      }
+    }
+  }
+
+
+  /**
+   * Reduce collection, returning a single result.
+   *
+   * @template T
+   * @template V
+   *
+   * @param {Collection<T>} collection
+   * @param {(result: V, entry: T, index: any) => V} iterator
+   * @param {V} result
+   *
+   * @return {V} result returned from last iterator
+   */
+  function reduce(collection, iterator, result) {
+
+    forEach(collection, function(value, idx) {
+      result = iterator(result, value, idx);
+    });
+
+    return result;
+  }
+
+
+  function identity(arg) {
+    return arg;
+  }
+
+  function toNum(arg) {
+    return Number(arg);
+  }
+
+  class Processor {
+      constructor(options) {
+          this.selfOptions = options || {};
+          this.pipes = {};
+      }
+      options(options) {
+          if (options) {
+              this.selfOptions = options;
+          }
+          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;
+              }
+          }
+          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
+      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);
+              }
+              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
+  class Pipe {
+      constructor(name) {
+          this.name = name;
+          this.filters = [];
+      }
+      process(input) {
+          if (!this.processor) {
+              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 (debug) {
+                  this.log(`filter: ${filter.filterName}`);
+              }
+              filter(context);
+              if (typeof context === 'object' && context.exiting) {
+                  context.exiting = false;
+                  break;
+              }
+          }
+          if (!context.next && this.resultCheck) {
+              this.resultCheck(context);
+          }
+      }
+      log(msg) {
+          console.log(`[jsondiffpatch] ${this.name} pipe, ${msg}`);
+      }
+      append(...args) {
+          this.filters.push(...args);
+          return this;
+      }
+      prepend(...args) {
+          this.filters.unshift(...args);
+          return this;
+      }
+      indexOf(filterName) {
+          if (!filterName) {
+              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) {
+                  return index;
+              }
+          }
+          throw new Error(`filter not found: ${filterName}`);
+      }
+      list() {
+          return this.filters.map((f) => f.filterName);
+      }
+      after(filterName, ...params) {
+          const index = this.indexOf(filterName);
+          this.filters.splice(index + 1, 0, ...params);
+          return this;
+      }
+      before(filterName, ...params) {
+          const index = this.indexOf(filterName);
+          this.filters.splice(index, 0, ...params);
+          return this;
+      }
+      replace(filterName, ...params) {
+          const index = this.indexOf(filterName);
+          this.filters.splice(index, 1, ...params);
+          return this;
+      }
+      remove(filterName) {
+          const index = this.indexOf(filterName);
+          this.filters.splice(index, 1);
+          return this;
+      }
+      clear() {
+          this.filters.length = 0;
+          return this;
+      }
+      shouldHaveResult(should) {
+          if (should === false) {
+              this.resultCheck = null;
+              return;
+          }
+          if (this.resultCheck) {
+              return;
+          }
+          this.resultCheck = (context) => {
+              if (!context.hasResult) {
+                  console.log(context);
+                  const error = new Error(`${this.name} failed`);
+                  error.noResult = true;
+                  throw error;
+              }
+          };
+          return this;
+      }
+  }
+
+  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);
+      }
+      const cloned = {};
+      for (const name in arg) {
+          if (Object.prototype.hasOwnProperty.call(arg, name)) {
+              cloned[name] = clone(arg[name]);
+          }
+      }
+      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]);
+              }
+          }
+          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;
+              }
+          }
+          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;
+          }
+      }
+      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;
+          }
+      }
+      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
+
+  */
+  const defaultMatch = function (array1, array2, index1, index2) {
+      return array1[index1] === array2[index2];
+  };
+  const lengthMatrix = function (array1, array2, match, context) {
+      const len1 = array1.length;
+      const len2 = array2.length;
+      let x, 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);
+          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;
+  };
+  const backtrack = function (matrix, array1, array2, context) {
+      let index1 = array1.length;
+      let index2 = array2.length;
+      const subsequence = {
+          sequence: [],
+          indices1: [],
+          indices2: [],
+      };
+      while (index1 !== 0 && index2 !== 0) {
+          const 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 {
+              const valueAtMatrixAbove = matrix[index1][index2 - 1];
+              const valueAtMatrixLeft = matrix[index1 - 1][index2];
+              if (valueAtMatrixAbove > valueAtMatrixLeft) {
+                  --index2;
+              }
+              else {
+                  --index1;
+              }
+          }
+      }
+      return subsequence;
+  };
+  const get = function (array1, array2, match, context) {
+      const innerContext = context || {};
+      const matrix = lengthMatrix(array1, array2, match || defaultMatch, innerContext);
+      return backtrack(matrix, array1, array2, innerContext);
+  };
+  var lcs = {
+      get,
+  };
+
+  const ARRAY_MOVE = 3;
+  function arraysHaveMatchByRef(array1, array2, len1, len2) {
+      for (let index1 = 0; index1 < len1; index1++) {
+          const val1 = array1[index1];
+          for (let index2 = 0; index2 < len2; index2++) {
+              const val2 = array2[index2];
+              if (index1 !== index2 && val1 === val2) {
+                  return true;
+              }
+          }
+      }
+  }
+  function matchItems(array1, array2, index1, index2, context) {
+      const value1 = array1[index1];
+      const value2 = array2[index2];
+      if (value1 === value2) {
+          return true;
+      }
+      if (typeof value1 !== 'object' || typeof value2 !== 'object') {
+          return false;
+      }
+      const 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 || [];
+      let 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 || [];
+      let hash2 = context.hashCache2[index2];
+      if (typeof hash2 === 'undefined') {
+          context.hashCache2[index2] = hash2 = objectHash(value2, index2);
+      }
+      if (typeof hash2 === 'undefined') {
+          return false;
+      }
+      return hash1 === hash2;
+  }
+  const diffFilter$2 = function arraysDiffFilter(context) {
+      if (!context.leftIsArray) {
+          return;
+      }
+      const matchContext = {
+          objectHash: context.options && context.options.objectHash,
+          matchByPosition: context.options && context.options.matchByPosition,
+      };
+      let commonHead = 0;
+      let commonTail = 0;
+      let index;
+      let index1;
+      let index2;
+      const array1 = context.left;
+      const array2 = context.right;
+      const len1 = array1.length;
+      const len2 = array2.length;
+      let 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++;
+      }
+      let 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[`_${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)
+      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',
+      };
+      for (index = commonHead; index < len1 - commonTail; index++) {
+          if (seq.indices1.indexOf(index - commonHead) < 0) {
+              // removed
+              result[`_${index}`] = [array1[index], 0, 0];
+              removedItems.push(index);
+          }
+      }
+      let detectMove = true;
+      if (context.options &&
+          context.options.arrays &&
+          context.options.arrays.detectMove === false) {
+          detectMove = false;
+      }
+      let includeValueOnMove = false;
+      if (context.options &&
+          context.options.arrays &&
+          context.options.arrays.includeValueOnMove) {
+          includeValueOnMove = true;
+      }
+      const removedItemsLength = removedItems.length;
+      for (index = commonHead; index < len2 - commonTail; index++) {
+          const indexOnArray2 = seq.indices2.indexOf(index - commonHead);
+          if (indexOnArray2 < 0) {
+              // added, try to match with a removed item and register as position move
+              let isMove = false;
+              if (detectMove && removedItemsLength > 0) {
+                  for (let 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[`_${index1}`].splice(1, 2, index, ARRAY_MOVE);
+                          if (!includeValueOnMove) {
+                              // don't include moved value on diff, to save bytes
+                              result[`_${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';
+  const compare = {
+      numerically(a, b) {
+          return a - b;
+      },
+      numericallyBy(name) {
+          return (a, b) => a[name] - b[name];
+      },
+  };
+  const patchFilter$1 = function nestedPatchFilter(context) {
+      if (!context.nested) {
+          return;
+      }
+      const nestedDelta = context.delta;
+      if (nestedDelta._t !== 'a') {
+          return;
+      }
+      let index;
+      let index1;
+      const delta = nestedDelta;
+      const array = context.left;
+      // first, separate removals, insertions and modifications
+      let toRemove = [];
+      let toInsert = [];
+      const toModify = [];
+      for (index in delta) {
+          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));
+                  }
+                  else {
+                      throw new Error('only removal or move can be applied at original array indices,' +
+                          ` invalid diff type: ${delta[removedOrMovedIndex][2]}`);
+                  }
+              }
+              else {
+                  const 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];
+          const indexDiff = delta[`_${index1}`];
+          const 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'));
+      const toInsertLength = toInsert.length;
+      for (index = 0; index < toInsertLength; index++) {
+          const insertion = toInsert[index];
+          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);
+              context.push(child, modification.index);
+          }
+      }
+      if (!context.children) {
+          context.setResult(array).exit();
+          return;
+      }
+      context.exit();
+  };
+  patchFilter$1.filterName = 'arrays';
+  const collectChildrenPatchFilter = function collectChildrenPatchFilter(context) {
+      if (!context || !context.children) {
+          return;
+      }
+      const deltaWithChildren = context.delta;
+      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 arrayIndex = child.childName;
+          array[arrayIndex] = child.result;
+      }
+      context.setResult(array).exit();
+  };
+  collectChildrenPatchFilter.filterName = 'arraysCollectChildren';
+  const reverseFilter$1 = function arraysReverseFilter(context) {
+      if (!context.nested) {
+          const nonNestedDelta = context.delta;
+          if (nonNestedDelta[2] === ARRAY_MOVE) {
+              const arrayMoveDelta = nonNestedDelta;
+              context.newName = `_${arrayMoveDelta[1]}`;
+              context
+                  .setResult([
+                  arrayMoveDelta[0],
+                  parseInt(context.childName.substring(1), 10),
+                  ARRAY_MOVE,
+              ])
+                  .exit();
+          }
+          return;
+      }
+      const nestedDelta = context.delta;
+      if (nestedDelta._t !== 'a') {
+          return;
+      }
+      const arrayDelta = nestedDelta;
+      let name;
+      let child;
+      for (name in arrayDelta) {
+          if (name === '_t') {
+              continue;
+          }
+          child = new ReverseContext(arrayDelta[name]);
+          context.push(child, name);
+      }
+      context.exit();
+  };
+  reverseFilter$1.filterName = 'arrays';
+  const 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 `_${index}`;
+      }
+      let reverseIndex = +index;
+      for (const deltaIndex in delta) {
+          const deltaItem = delta[deltaIndex];
+          if (Array.isArray(deltaItem)) {
+              if (deltaItem[2] === ARRAY_MOVE) {
+                  const moveFromIndex = parseInt(deltaIndex.substring(1), 10);
+                  const 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) {
+                  const deleteIndex = parseInt(deltaIndex.substring(1), 10);
+                  if (deleteIndex <= reverseIndex) {
+                      reverseIndex++;
+                  }
+              }
+              else if (deltaItem.length === 1 &&
+                  parseInt(deltaIndex, 10) <= reverseIndex) {
+                  reverseIndex--;
+              }
+          }
+      }
+      return reverseIndex;
+  };
+  const collectChildrenReverseFilter = (context) => {
+      if (!context || !context.children) {
+          return;
+      }
+      const deltaWithChildren = context.delta;
+      if (deltaWithChildren._t !== 'a') {
+          return;
+      }
+      const arrayDelta = deltaWithChildren;
+      const length = context.children.length;
+      let child;
+      const delta = {
+          _t: 'a',
+      };
+      for (let index = 0; index < length; index++) {
+          child = context.children[index];
+          let 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';
+
+  const 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';
+
+  const TEXT_DIFF = 2;
+  const DEFAULT_MIN_LENGTH = 60;
+  let cachedDiffPatch = null;
+  function getDiffMatchPatch(options, required) {
+      var _a;
+      if (!cachedDiffPatch) {
+          let 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;
+              }
+              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) {
+                  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');
+                          error.textPatchFailed = true;
+                      }
+                  }
+                  return results[0];
+              },
+          };
+      }
+      return cachedDiffPatch;
+  }
+  const diffFilter = function textsDiffFilter(context) {
+      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;
+      if (left.length < minLength || right.length < minLength) {
+          context.setResult([left, right]).exit();
+          return;
+      }
+      // large text, try to use a text-diff algorithm
+      const diffMatchPatch = getDiffMatchPatch(context.options);
+      if (!diffMatchPatch) {
+          // diff-match-patch library not available,
+          // fallback to regular string replace
+          context.setResult([left, right]).exit();
+          return;
+      }
+      const diff = diffMatchPatch.diff;
+      context.setResult([diff(left, right), 0, TEXT_DIFF]).exit();
+  };
+  diffFilter.filterName = 'texts';
+  const patchFilter = function textsPatchFilter(context) {
+      if (context.nested) {
+          return;
+      }
+      const nonNestedDelta = context.delta;
+      if (nonNestedDelta[2] !== TEXT_DIFF) {
+          return;
+      }
+      const textDiffDelta = nonNestedDelta;
+      // text-diff, use a text-patch algorithm
+      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;
+      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 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');
+  };
+  const reverseFilter = function textsReverseFilter(context) {
+      if (context.nested) {
+          return;
+      }
+      const nonNestedDelta = context.delta;
+      if (nonNestedDelta[2] !== TEXT_DIFF) {
+          return;
+      }
+      const textDiffDelta = nonNestedDelta;
+      // text-diff, use a text-diff algorithm
+      context
+          .setResult([textDeltaReverse(textDiffDelta[0]), 0, TEXT_DIFF])
+          .exit();
+  };
+  reverseFilter.filterName = 'texts';
+
+  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)
+              .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());
+      }
+      options(options) {
+          return this.processor.options(options);
+      }
+      diff(left, right) {
+          return this.processor.process(new DiffContext(left, right));
+      }
+      patch(left, delta) {
+          return this.processor.process(new PatchContext(left, delta));
+      }
+      reverse(delta) {
+          return this.processor.process(new ReverseContext(delta));
+      }
+      unpatch(right, delta) {
+          return this.patch(right, this.reverse(delta));
+      }
+      clone(value) {
+          return clone(value);
+      }
+  }
+
+  /* eslint no-cond-assign: 0 */
+
+  function is(element, type) {
+    return element.$instanceOf(type);
+  }
+
+  function isAny(element, types) {
+    return types.some(function(t) {
+      return is(element, t);
+    });
+  }
+
+  function isTracked(element) {
+
+    const track = isAny(element, [
+      'od:OdBoard',
+      'od:Object',
+      'od:Link',
+    ]);
+
+    if (track) {
+      return {
+        element: element,
+        property: ''
+      };
+    }
+  }
+
+  function ChangeHandler() {
+    this._layoutChanged = {};
+    this._changed = {};
+    this._removed = {};
+    this._added = {};
+  }
+
+
+  ChangeHandler.prototype.removed = function(model, property, element, idx) {
+
+    let tracked;
+
+    if (tracked = isTracked(element)) {
+      if (!this._removed[tracked.element.id]) {
+        this._removed[tracked.element.id] = element;
+      }
+    } else
+
+      if (tracked = isTracked(model)) {
+        this.changed(tracked.element, tracked.property + property + '[' + idx + ']', null, element);
+      }
+  };
+
+  ChangeHandler.prototype.changed = function(model, property, newValue, oldValue) {
+
+    let tracked;
+
+    if (tracked = isTracked(model)) {
+      let changed = this._changed[tracked.element.id];
+
+      if (!changed) {
+        changed = this._changed[tracked.element.id] = { model: model, attrs: { } };
+      }
+
+      if (oldValue !== undefined || newValue !== undefined) {
+        changed.attrs[property] = { oldValue: oldValue, newValue: newValue };
+      }
+    }
+  };
+
+  ChangeHandler.prototype.added = function(model, property, element, idx) {
+
+    let tracked;
+
+    if (tracked = isTracked(element)) {
+      if (!this._added[tracked.element.id]) {
+        this._added[tracked.element.id] = element;
+      }
+    } else
+
+      if (tracked = isTracked(model)) {
+        this.changed(tracked.element, tracked.property + property + '[' + idx + ']', element, null);
+      }
+  };
+
+  ChangeHandler.prototype.moved = function(model, property, oldIndex, newIndex) {
+
+    // noop
+  };
+
+  function Differ() { }
+
+
+  Differ.prototype.createDiff = function(a, b) {
+
+    // create a configured instance, match objects by name
+    const diffpatcher = new DiffPatcher({
+      objectHash: function(obj) {
+        return obj.id || JSON.stringify(obj);
+      },
+      propertyFilter: function(name, context) {
+        return name !== '$instanceOf';
+      }
+    });
+
+    return diffpatcher.diff(a, b);
+  };
+
+
+  Differ.prototype.diff = function(a, b, handler) {
+
+    handler = handler || new ChangeHandler();
+
+    function walk(diff, model) {
+
+      forEach(diff, function(d, key) {
+
+        if (d._t !== 'a' && isArray(d)) {
+
+          // take into account that collection properties are lazily
+          // initialized; this means that adding to an empty collection
+          // looks like setting an undefined variable to []
+          //
+          // ensure we detect this case and change it to an array diff
+          if (isArray(d[0])) {
+
+            d = reduce(d[0], function(newDelta, element, idx) {
+              const prefix = d.length === 3 ? '_' : '';
+
+              newDelta[prefix + idx] = [ element ];
+
+              return newDelta;
+            }, { _t: 'a' });
+          }
+
+        }
+
+
+        // is array
+        if (d._t === 'a') {
+
+          forEach(d, function(val, idx) {
+
+            if (idx === '_t') {
+              return;
+            }
+
+            const removed = /^_/.test(idx),
+                  added = !removed && isArray(val),
+                  moved = removed && val[0] === '';
+
+            idx = parseInt(removed ? idx.slice(1) : idx, 10);
+
+            if (added || (removed && !moved)) {
+              handler[removed ? 'removed' : 'added'](model, key, val[0], idx);
+            } else
+              if (moved) {
+                handler.moved(model, key, val[1], val[2]);
+              } else {
+                walk(val, model[key][idx]);
+              }
+          });
+        } else {
+          if (isArray(d)) {
+            handler.changed(model, key, d[0], d[1]);
+          } else {
+            handler.changed(model, key);
+            walk(d, model[key]);
+          }
+        }
+      });
+    }
+
+    const diff = this.createDiff(a, b);
+
+    walk(diff, b);
+
+    return handler;
+  };
+
+  function diff(a, b, handler) {
+    return new Differ().diff(a, b, handler);
+  }
+
+  return diff;
+
+}));