    graph.bfs(element, iteratee [, opt])

Traverse the graph using the Breadth-first search algorithm starting at `element` (note the element itself will be visited too). `iteratee` is a function of the form `function(element, distance) {}` that will be called with the currently visited element and distance of that element from the root element of the search (the `element` passed to `bfs()`). If `iteratee` explicitely returns `false`, the search stops.

The following image shows the order in which elements are traversed in the graph:

Note that the `bfs()` algorithm is not only capable of traversing tree graphs but it can traverse any directed graph too.

It is smart enough not to traverse an element that was already visited.

If `opt.inbound` is `true`, reverse the search direction (it's like reversing all the link directions, i.e. swaping their `source` and `target`).

If `opt.outbound` is `true`, search follows the link directions. Calling `bfs()` with `opt.outbound` set to `true` is the most common case (graph is traversed following the direction of links).

If none of `opt.inbound` and `opt.outbound` are used or both options are set to `true`, the graph is traversed in both directions (very rare use case).

If `opt.deep` is `true`, the traversal takes into account embedded elements too. This option has the usual meaning as in other methods were `deep` option is used. For example, in a hierarchy A (top level element), A1 (embedded in A), B (top level element), where A is not directly connected to B but its embedded element is (there is a link from A1 ----> B), bfs(A)would not visit B but bfs(A, function() {}, { deep: true }) would.