Lazy lists with transformations, using generators & iterators
I can not find fault with your code apart from the use of class of which i am not a fan. 

So I will just present an alternative syntax that gives a little extra encapsulated protection. Its usage is slightly different. List is instantiated via a factory and closure holds the generator list. I also freeze each instance of List to further protect the state. 

It also does not have to mess about with const list = this which from your side-note comment is a bit of an annoyance.

const lazyList = (() =&gt; {

    const range = (start, end) =&gt; List(function* () {
       while(start &lt;= end) { yield start++ }
    });    
    function List(source) {
        var list;
        if (typeof source === "function") { list = source }
        else { list = function* () { yield* source } }

        return Object.freeze({
            filter(pred){
                return List(function* () {
                    for (const item of list()) { pred(item) ? yield item : 0 }
                });
            },
            map(map) {
                return List(function* () {
                    for (const item of list()) { yield map(item) }
                });
            },
            take(count) {
                return List(function* () {
                    for (const item of list()) {
                        if (count--) { yield item }
                        else { break }
                    }
                });
            },
            toArray() { return [...list()] },
            *[Symbol.iterator] () { yield* list() }
        });
    } 
    return Object.freeze({range, List});

})();