function *makeIterator(array){
    var nextIndex = 0;

    while (nextIndex < array.length) {
        yield array[nextIndex++];
    }
}

var iterator = makeIterator([1,2,3]);

for (var key of iterator) {
    alert(key);
}

for (var key of (el for (el of [1,2,3]))) {
    alert(key);
}

let room = new Room();
let character = new Character({room});
assert.equal(character.room, room);

room.destroy();
assert.isNull(character.room);
assert.isNull(room); //!!!

const revoke = Symbol();

class Model {
    constructor() {
        let {
            proxy,
            revoke: revokeHandler
        } = Proxy.revocable(this, {});
        
        this[revoke] = revokeHandler;
  
        return proxy;
    }
    
    destroy() {
       this[revoke]();
    }
}

class Character extends Model {
    constructor(room) {
        super();
        Object.assign(this, {
            room
        });
    }
}

class Room extends Model {}

class Deferred {

    constructor(generator) {
        this.promise = new Promise((resolve, reject) => {
            Object.assign(this, {resolve, reject});
        });
        generator.next();
        let next = value => {
            let result = generator.next(value);
            if (!result.done) {
                value = result.value;
                if (value && value.next) {
                    new Deferred(value).done(next).fail(this.reject);
                } else {
                    next(value);
                }
            }
        };
        next(this);
    }

    done(onFulfilled) {
        this.promise.then(onFulfilled);
        return this;
    }
    
    fail(onRejected) {
        this.promise.catch(onRejected);
        return this;
    }

}

function * getFoo() {
    let deferred = yield;
    setTimeout(function() {
        deferred.resolve('foo');
    }, 100);
}

function * getBar() {
    let deferred = yield;
    let foo = yield getFoo();
    setTimeout(function() {
        deferred.resolve(foo + 'bar');
    }, 100);
}

new Deferred(getBar()).done(function(value) {
    console.log(value);
});

// в консоль выведется "foobar"

alert`1`

"use strict";

var _taggedTemplateLiteral = function (strings, raw) { return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); };

alert(_taggedTemplateLiteral(["1"], ["1"]));

var myStr = `
  Hello ${name}!
  I'm glad to see you.
`;

var myStr = n2br`
  Hello ${name}!
  I'm glad to see you.
`;

class X {
	'method'() {
		
	}
}

class X {
	'method'() {
		
	}
}

class X {
	method() {

	}

	'@method'() {

	}

	[1 + 2]() {

	}
}

function html(arr, ...vars) {
    return arr.reduce((str, el, i) => str += EscapeStr(vars[i - 1]) + el);
}

var str = html`Hello ${name}`;

try {
    var string = [Symbol()].join();
} catch(e) {
    alert(e.message);
}
alert(string);

var string = [Symbol().toString()].join();
alert(string);

ChildClass.__proto__ = SuperClass;
SuperClass.staticProperty = 1;
ChildClass.staticProperty → 1

Bar.inherit(Foo);

@abstract class Model {
    constructor(data) {
        Object.assign(this, data);
    }
}

console.log(new Model()); //TypeError: Cannot directly instantiate an abstract class

function abstract(target) {
    return new Proxy(target, {
        construct() {
            throw new TypeError("Cannot directly instantiate an abstract class");
        }
    })
}

app.get('/query', function*() {
    let _this = this;

    setTimeout(function() {
      _this.body = 'ответ';
    }, 100);
});

app.get('/query', function*() {
    this.body = yield getBody();
});

$(".some-link").on("click", ::view.reset);

$(".some-link").on("click", view.reset.bind(view));

class Foo {
  // Публичное свойство
  a = 1;

  // Приватное свойство
  @b = 2;

  // Хз, можно ли так объявлять приватные методы, но вообще логично
  @foo() {
    // Обращение к приватному свойству
    this.@b = 3;
  }
}

$(".some-link").on("click", function () { return view.reset.apply(this, arguments); });

$(".some-link").on("click", ::view.reset);

$(".some-link").on("click", view.reset.bind(view));

let m = new Map()
m.set("hello", 42)
m.set(s, 34) // что такое s?!
m.get(s) === 34
m.size === 2
for (let [ key, val ] of m.entries())
    console.log(key + " = " + val)

var m = {};
m["hello"] = 42;
// no equivalent in ES5 // да есть эквивалент (реализуется через массив)
// no equivalent in ES5 // и тут есть
Object.keys(m).length === 2;
for (key in m) {
    if (m.hasOwnProperty(key)) {
        var val = m[key];
        console.log(key + " = " + val);
    }
}