Generators in Node.js - Fiber or pure JavaScript?

I am trying to implement generators in Node.js. I came across node-fiber and node-lazy. Node-lazy deals with arrays and streams, but does not generate lazy things inherently (except numbers).

While using fiber looks cleaner, it has its cons, and as such, I prefer pure Javascript with closures as it's more explicit. My question is: are there memory or perf problems using closure to generate an iterator?

As an example, I'm trying to iterate through a tree depth-first, for as long as the caller asks for it. I want to find 'waldo' and stop at the first instance.

Fiber:

var depthFirst = Fiber(function iterate(tree) {
    tree.children.forEach(iterate);
    Fiber.yield(tree.value);
});

var tree = ...;
depthFirst.run(tree);
while (true) {
    if (depthFirst.run() === 'waldo')
        console.log('Found waldo');
}

Pure JavaScript with closures:

function iterate(tree) {
    var childIndex = 0;
    var childIter = null;
    var returned = false;
    return function() {
        if (!childIter && childIndex < tree.children.length)
            childIter = iterate(tree.children[childIndex++]);

        var result = null;
        if (childIter && (result = childIter()))
            return result;

        if (!returned) {
            returned = true;
            return tree.value;
        }
    };
}

var tree = ...;
var iter = iterate(tree);
while (true) {
    if (iter() === 'waldo')
        console.log('found waldo');
}