const target = {
  secret: "hidden",
  reveal: "nothing"
};

const handler = {
  get: function(obj, prop, receiver) {
    if (prop === "secret") {
      return "revealed";
    }
    return Reflect.get(...arguments);
  }
};

const proxy = new Proxy(target, handler);

with (proxy) {
  console.log(secret);
  console.log(reveal);
}

const items = ['apple', 'banana', 'cherry', 'date'];  

const result = items
  .map(item => item.toUpperCase())
  .filter(item => item.length > 5)
  .reduce((acc, item, index) => {
    return acc + (index === 0 ? '' : '-') + item.slice(0, 3);
  }, '');

console.log(result);

const array = [1, 2, 3];
array[-1] = 0;

console.log(array.length);

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

const result = numbers
  .filter(n => n % 2 === 0)
  .map(n => n * 2)
  .reduce((acc, curr, idx, arr) => {
    if (idx === arr.length - 1) {
      return (acc + curr) / arr.length;
    }
    return acc + curr;
  }, 0);

console.log(result);

const weakMap = new WeakMap();
const obj = {};

(function() {
  const internalObj = {};
  weakMap.set(internalObj, 'hidden');
  obj.ref = internalObj;
})();

delete obj.ref;

const result = weakMap.has(obj.ref);

console.log(result);

const teams = [
  { name: 'Warriors', players: ['Curry', 'Thompson'] },
  { name: 'Lakers', players: ['James', 'Davis'] }
];

const newTeams = JSON.parse(JSON.stringify(teams));
newTeams[0].players.push('Green');

const shallowCopy = [...teams];
shallowCopy[1].name = 'Clippers';

const freezeTest = Object.freeze({nested: {value: 42}});
freezeTest.nested.value = 100;

console.log(teams[1].name, teams[0].players.length, freezeTest.nested.value);

let x = 5;
function addFive(num) {
   return num + 5;
}
x = (x++, x = addFive(x), x *= 2, x -= 5, x += 10);
console.log(x);

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

let x = 5;

function foo() {
  console.log(x);
  let x = 10;
  console.log(x);
}

foo();

const numbers = [0,0,0];

let i = 0;
const result = numbers.reduce((acc, _) => {
  return ++acc;
}, i);

console.log(i, result);

const fruits = ['apple', 'banana', 'cherry'];
const newFruits = [...fruits];

newFruits.push('date');

const user = { name: 'Taylor', age: 30 };
const updatedUser = { ...user, age: 31 };

user.city = 'Seattle';

console.log(fruits.length, newFruits.length, user.city, updatedUser.city);

const str = "a 1 b 2 c 3 d 04";

function foo(str) {
   const regex = /\d+/g;
   const matches = str.match(regex);
   return matches.lenght;
}

const add = x => y => x + y;
const multiply = x => y => x * y;
const subtract = x => y => x - y;

const result = add(10)(multiply(2)(subtract(5)(3)));
console.log(result);

const handler = {
  get(target, prop) {
    if (prop in target) {
      return target[prop] * 2;
    } else {
      return `Property ${prop} not found`;
    }
  },
  set(target, prop, value) {
    if (typeof value === 'number') {
      target[prop] = Math.round(value);
      return true;
    }
    return false;
  }
};

const obj = { a: 5, b: 10 };
const proxy = new Proxy(obj, handler);

proxy.c = 7.8;
proxy.d = "hello";

console.log(obj.c, proxy.a, proxy.x);

class Rectangle {
  constructor(width, height) {
    this.width = width;
    this.height = height;
  }

  get area() {
    return this.width * this.height;
  }
}

const rectangle = new Rectangle(5, 10);
console.log(rectangle.area());

async function foo() {
  console.log('Start');
  await Promise.resolve().then(() => {
    console.log('Inside Promise');
  });
  console.log('End');
}

foo();
console.log('Outside');

const map = new WeakMap();

let obj1 = { name: 'user1' };
let obj2 = { name: 'user2' };

map.set(obj1, 'data for user1');
map.set(obj2, 'data for user2');

console.log(map.has(obj1));
obj1 = null;

// After garbage collection runs
console.log(map.has(obj1));
console.log(map.get(obj2));

const a = [1, 2, 3];
const b = a.flatMap(x => [x, x * 2]);
console.log(b);

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

var a = 'b';
var b = 'c';

(function () {
   console.log(a);
   var a = 'd';
   b = 'e';
   console.log(b);
})();

console.log(a);
console.log(b);

let obj1 = { key: 'value1' };
let obj2 = { key: 'value2' };

const weakMap = new WeakMap();
weakMap.set(obj1, 'data1');
weakMap.set(obj2, 'data2');

obj1 = null;
setTimeout(() => {
  console.log(weakMap.has(obj1));
  console.log(weakMap.has(obj2));
}, 100);