code: function diff (a, b, eql) {
    eql = eql || strictEqual
  
    var N = a.length
    var M = b.length
    var MAX = N + M
  
    var V = {}
    var Vs = []
  
    V[1] = 0
    for (var D = 0; D <= MAX; D += 1) {
      for (var k = -D; k <= D; k += 2) {
        var x, y
  
        if (k === -D || (k !== D && V[k - 1] < V[k + 1])) {
          x = V[k + 1]
        } else {
          x = V[k - 1] + 1
        }
  
        y = x - k
        while (x < N && y < M && eql(a[x], b[y])) {
          x += 1
          y += 1
        }
  
        V[k] = x
        if (x >= N && y >= M) {
          Vs[D] = assign({}, V)
          return buildEdits(Vs, a, b)
        }
      }
  
      Vs[D] = assign({}, V)
    }
  
    // ?
    throw Error('Unreachable diff path reached')
  }
docs: diff(a, b [, eql]) diffs the array-like objects `a` and `b`, returning
  a summary of the edits made. By default, strict equality (`===`) is
  used to compare items in `a` and `b`; if this will not work (for example,
  if the items in `a` and `b` are objects), a custom equality function,
  `eql`, may be passed as a third argument.
  
  @param {Array} a
  @param {Array} b
  @param {Function} eql
  @return {Array}