function* genSequence() {
  const result = yield 'first';
  console.log(result);
  yield* [1, 2];
  return 'done';
}

const gen = genSequence();
let next = gen.next('ignored');
console.log(next.value);
next = gen.next('second');
next = gen.next();
console.log(next.value);
next = gen.next();
console.log(next);

function Animal(name) {
  this.name = name;
}

Animal.prototype.speak = function() {
  return `${this.name} makes a noise`;
};

function Dog(name) {
  Animal.call(this, name);
}

Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;

Dog.prototype.speak = function() {
  return `${this.name} barks`;
};

const animal = new Animal('Animal');
const dog = new Dog('Rex');

console.log(dog instanceof Animal);

const str = "  Hello, World!  ";

const result = str
  .trim()
  .split(", ")
  .map((word, i) => {
    if (i % 2 === 0) return word.toUpperCase();
    return word.toLowerCase().replace("!", "@");
  })
  .reverse()
  .join(" | ");

console.log(result);

function outer() {
  var x = 2;
  
  function inner() {
    let x = 4;
    
    function deeper() {
      console.log(x);
    }
    
    return deeper;
  }
  
  return inner();
}

const fn = outer();
fn();

function addCommas(money){
  var re=/\d{3}(?!$)/g
  return money.replace(re,x=>x+",")
}
console.log( addCommas("$123456789") )  
console.log( addCommas("$123456") )    
console.log( addCommas("$1234567890") ) 
console.log( addCommas("$1234567") )

function tricky() {
  let a = 1;
  let b = 2;
  const result = (function(a) {
    a = 3;
    return a + b;
  })(a);
  return result;
}

console.log(tricky());

async function getData() {
  return Promise.resolve(1);
}

async function process() {
  try {
    const x = await getData();
    const y = await Promise.resolve(x + 1);
    console.log(y + await Promise.resolve(1));
  } catch(err) {
    console.log('Error');
  }
}

process();

const nums = [1, 2, 3, 4];
const res = nums.reduce((acc, val) => acc + val, 2);
console.log(typeof res);

function trickyScope() {
    let x = 10;
    if (true) {
        let x = 20;
        console.log(x); // A
    }
    console.log(x); // B
    {
        let x = 30;
        console.log(x); // C
    }
    console.log(x); // D
}

trickyScope();

const counter = {
  count: 0,
  increment() {
    this.count++;
    return this.count;
  }
};

const inc = counter.increment;
const boundInc = counter.increment.bind(counter);

console.log([
  counter.increment(),
  inc(),
  boundInc(),
  counter.count
]);

var str="abcdef";
console.log( str.match(/./g) )   
console.log( str.match(/../g) ) 
console.log( str.match(/.../g) )

function processConfig(config) {
  const cache = config.cache ?? true;
  const timeout = config.timeout ?? 1000;
  const retries = config.retries ?? 3;
  
  return {
    useCache: cache,
    timeoutMs: timeout,
    maxRetries: retries
  };
}

const result = processConfig({ timeout: 0, retries: false });
console.log(result);

const team = {
  name: 'Eagles',
  players: ['Smith', 'Johnson', 'Williams'],
  coach: { name: 'Brown', experience: 12 },
  stats: { wins: 10, losses: 6 }
};

const { 
  name: teamName, 
  players: [firstPlayer, , thirdPlayer],
  coach: { name },
  stats: { wins, draws = 0 }
} = team;

console.log(`${teamName}-${firstPlayer}-${thirdPlayer}-${name}-${wins}-${draws}`);

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

const person = {
  name: 'Alice',
  greet() {
    return `Hello, I'm ${this.name}`;
  },
  farewell: () => `Goodbye from ${this.name}`
};

const greetFn = person.greet;
const farewellFn = person.farewell;

console.log(person.greet());
console.log(greetFn());
console.log(farewellFn());

const numbers = [1, 2, 3, 4, 5];

const sum = numbers.reduce((acc, curr) => {
  setTimeout(() => {
    acc += curr;
  }, 0);
  return acc;
}, 0);

console.log(sum);

function processData(data) {
  try {
    if (!data) {
      throw new TypeError('Data is required');
    }
    
    if (data.status === 'error') {
      throw new Error('Invalid status');
    }
    
    return data.value.toUpperCase();
  } catch (err) {
    if (err instanceof TypeError) {
      return 'Type Error';
    }
    return err.message;
  }
}

console.log(processData({ status: 'error', value: 'test' }));

const target = { a: 1, b: 2 };
const handler = {
  get(obj, prop) {
    return prop === 'sum' ? obj.a + obj.b : Reflect.get(obj, prop);
  },
  set(obj, prop, value) {
    if (prop === 'a' && value < 0) {
      return false;
    }
    return Reflect.set(obj, prop, value);
  }
};

const proxy = new Proxy(target, handler);
proxy.a = -5;
proxy.b = 10;
console.log(`${proxy.a}, ${proxy.b}, ${proxy.sum}`);