console.log(1);
setTimeout(() => console.log(2), 0);
Promise.resolve()
  .then(() => {
    console.log(3);
    return Promise.resolve(4);
  })
  .then(console.log);
console.log(5);

function* createCounter() {
  let count = 0;
  while (true) {
    const reset = yield ++count;
    if (reset) {
      count = 0;
    }
  }
}

const counter = createCounter();
console.log(counter.next().value);
console.log(counter.next().value);
console.log(counter.next(true).value);
console.log(counter.next().value);

const base = { x: 1 };
const obj = Object.freeze(base);

base.y = 2;
console.log(base.y);

function createCounter() {
  let count = 0;
  
  const counter = {
    increment() {
      count++;
      return count;
    },
    getCount() {
      return count;
    }
  };
  
  return counter;
}

let c1 = createCounter();
c1.increment();
c1.increment();

let c2 = c1;
c1 = null;

console.log(c2.getCount());

const weakSet = new WeakSet();

const obj1 = { name: 'First' };
const obj2 = { name: 'Second' };
const obj3 = obj1;

weakSet.add(obj1);
weakSet.add(obj2);

let result = '';
result += weakSet.has(obj1) + ', ';
result += weakSet.has(obj3) + ', ';

obj2.name = 'Modified';
result += weakSet.has(obj2) + ', ';

weakSet.delete(obj1);
result += weakSet.has(obj3);

console.log(result);

const person = {
  name: "John",
  greet: function() {
    const getMessage = () => `Hello, ${this.name}`;
    return getMessage();
  }
};

console.log(person.greet());

const a = [1, 2, 3];
const b = a;

b[0] = 0;

console.log(a);

class LightMachine {
  constructor() {
    this.states = {
      green: { next: 'yellow' },
      yellow: { next: 'red' },
      red: { next: 'green' }
    };
    this.currentState = 'green';
  }

  transition() {
    this.currentState = this.states[this.currentState].next;
    return this.currentState;
  }
}

const lightMachine = new LightMachine();
let result = '';
for (let i = 0; i < 5; i++) {
  result += lightMachine.transition() + ' ';
}
console.log(result.trim());

console.log(0 || {} && 1);

async function processValues() {
  try {
    console.log('Start');
    const a = await Promise.resolve('First');
    console.log(a);
    const b = await Promise.reject('Error');
    console.log(b);
    return 'Done';
  } catch (err) {
    console.log(err);
    return 'Recovered';
  } finally {
    console.log('Finally');
  }
}

processValues().then(result => console.log(result));

const func = () => arguments.length;
console.log(func(1, 2, 3));

function greet(name) {
  return `Hello, ${name}!`;
}

function highlight(strings, ...values) {
  return strings.reduce((result, str, i) => {
    return result + str + (values[i] ? `<em>${values[i]}</em>` : '');
  }, '');
}

const user = 'Sarah';
const status = 'online';

console.log(highlight`User ${user} is currently ${status}.`);

function Person(name) {
  this.name = name;
  this.sayName = () => console.log(this.name);
}

const person1 = new Person('David');
const person2 = { name: 'Not David', sayName: person1.sayName };

person2.sayName();

const weakMap = new WeakMap();
const obj1 = {};
const obj2 = { key: 'value' };

weakMap.set(obj1, obj2);

const result = weakMap.get(obj1).key.split('').reverse().join('');

console.log(result);

function createCounter() {
  let count = 0;
  
  function increment() {
    count++;
    return count;
  }
  
  function decrement() {
    count--;
    return count;
  }
  
  return { increment, decrement, reset: () => count = 0 };
}

const counter = createCounter();
counter.increment();
counter.increment();
counter.decrement();

const { increment, reset } = counter;
increment();
reset();
increment();

console.log(counter.increment());

class VideoCall {
  constructor() {
    this.pc = { iceConnectionState: 'new' };
    this.streams = [];
  }
  
  async connect() {
    this.pc.iceConnectionState = 'checking';
    await Promise.resolve();
    this.pc.iceConnectionState = 'connected';
    this.streams.push('remote-video');
    return this.pc.iceConnectionState;
  }
  
  handleConnectionChange() {
    const states = ['new', 'checking', 'connected'];
    return states.map(state => {
      return this.pc.iceConnectionState === state ? `Status: ${state}` : null;
    }).filter(Boolean);
  }
}

const call = new VideoCall();
call.connect().then(() => {
  console.log(call.handleConnectionChange());
});

const obj = {
  a: 1,
  then(resolve) {
    resolve(this.a);
  }
};

obj.then(console.log);

console.log('Start');

setTimeout(() => {
  console.log('Timeout 1');
}, 0);

Promise.resolve().then(() => {
  console.log('Promise 1');
}).then(() => {
  console.log('Promise 2');
});

setTimeout(() => {
  console.log('Timeout 2');
}, 0);

console.log('End');

function getItems(fruitList, ...args, favoriteFruit) {
   return [...fruitList, ...args, favoriteFruit]
}

getItems(["banana", "apple"], "pear", "orange")

const obj = {
  value: 1,
  increment() {
    this.value++;
  }
};

const increment = obj.increment;
increment();

console.log(obj.value);