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 a = [1, 2, 3];
const b = a.slice(0, 2).push(4);
console.log(b);

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();

function foo() {
   return typeof arguments;
};
console.log(foo(1, 2, 3));

let symbol1 = Symbol('description');
let symbol2 = Symbol('description');

const obj = {
  [symbol1]: 'value1',
  [symbol2]: 'value2'
};

console.log(obj[symbol1]);
console.log(symbol1 === symbol2);

class Calculator {
  static multiply(a, b) {
    return a * b;
  }
  
  static add = (a, b) => {
    return a + b;
  }
}

class ScientificCalculator extends Calculator {
  static multiply(a, b) {
    return super.multiply(a, b) * 2;
  }
}

console.log(Calculator.multiply(3, 4));
console.log(ScientificCalculator.add(5, 6));
console.log(ScientificCalculator.multiply(2, 3));

const obj = {
  value: 42,
  [Symbol.toPrimitive](hint) {
    if (hint === 'number') return this.value * 2;
    if (hint === 'string') return `Value: ${this.value}`;
    return this.value + 10;
  }
};

console.log(+obj);
console.log(`${obj}`);
console.log(obj + 5);
console.log(Number(obj));

const matrix = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9],
];

let columnSums = [];

for (let i = 0; i < matrix[0].length; i++) {
  let sum = 0;
  for (let j = 0; j < matrix.length; j++) {
    sum += matrix[i][i];
  }
  columnSums.push(sum);
}
console.log(columnSums);

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

const counter = createCounter();

console.log(counter.increment());
console.log(counter.getCount());
console.log(counter.increment());
console.log(counter.getCount());

function* generator1() {
  yield 1;
  yield 2;
}

function* generator2() {
  yield* generator1();
  yield 3;
}

const gen = generator2();
console.log(gen.next().value);
console.log(gen.next().value);
console.log(gen.next().value);

class Logger {
  constructor(prefix) {
    this.prefix = prefix;
  }
  log(message) {
    console.log(`${this.prefix}: ${message}`);
  }
}

class Database {
  constructor(logger) {
    this.logger = logger;
  }
  save(data) {
    this.logger.log(`Saving ${data}`);
    return `${data}_saved`;
  }
}

const logger = new Logger('DB');
const db = new Database(logger);
const result = db.save('user');
console.log(result);

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());

const arr = [1, 2, 3, 4, 5];
const result = arr
  .map(x => x * 2)
  .filter(x => x > 5)
  .reduce((acc, val) => {
    return acc + (val % 3 === 0 ? val : 0);
  }, 0);

console.log(result);

const ws = new WeakSet();
const obj1 = { name: 'first' };
const obj2 = { name: 'second' };
const obj3 = obj1;

ws.add(obj1);
ws.add(obj2);
ws.add(obj3);

console.log(ws.has(obj1));
console.log(ws.has(obj3));
console.log(ws.has({ name: 'first' }));
console.log(ws.size);

function* innerGenerator() {
  yield 1;
  yield 2;
  return 'inner-done';
}

function* outerGenerator() {
  yield 'start';
  const result = yield* innerGenerator();
  yield result;
  yield 'end';
}

const gen = outerGenerator();
console.log(gen.next().value);
console.log(gen.next().value);
console.log(gen.next().value);
console.log(gen.next().value);
console.log(gen.next().value);

function processData() {
  const results = [];
  
  for (let i = 0; i < 3; i++) {
    const multiplier = i + 1;
    
    setTimeout(() => {
      results.push(i * multiplier);
    }, 0);
  }
  
  setTimeout(() => {
    console.log(results.join(','));
  }, 10);
}

processData();

class Calculator {
  constructor(value) {
    this.value = value;
  }
  
  add(num) {
    this.value += num;
    return this;
  }
  
  multiply(num) {
    this.value *= num;
    return this;
  }
}

const calc = new Calculator(5);
const addMethod = calc.add;
const result = addMethod.call(calc, 3).multiply(2);
console.log(result.value);

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

getOrder();

class EventEmitter {
  constructor() {
    this.events = new Map();
  }
  
  on(event, callback) {
    if (!this.events.has(event)) {
      this.events.set(event, []);
    }
    this.events.get(event).push(callback);
    return this;
  }
  
  emit(event, ...args) {
    const callbacks = this.events.get(event);
    if (callbacks) {
      callbacks.forEach(cb => cb(...args));
    }
    return this;
  }
}

const emitter = new EventEmitter();
emitter.on('test', x => console.log(x * 2))
       .on('test', x => console.log(x + 10))
       .emit('test', 5);

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());

const obj = {
  data: ['x', 'y', 'z'],
  *[Symbol.iterator]() {
    for (let i = this.data.length - 1; i >= 0; i--) {
      yield this.data[i].toUpperCase();
    }
  }
};

const result = [];
for (const item of obj) {
  result.push(item);
  if (result.length === 2) break;
}

console.log(result.join('-'));