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

function compose(...fns) {
  return (x) => fns.reduceRight((acc, fn) => fn(acc), x);
}

const counter = createCounter();
const double = x => x * 2;
const addOne = x => x + 1;

const incrementAndProcess = compose(double, addOne, counter.increment);

counter.increment();
const result = incrementAndProcess();
console.log(result);

const handler = {
  get(target, prop, receiver) {
    if (prop === 'secret') {
      return Reflect.get(...arguments) + ' exposed';
    }
    return Reflect.get(...arguments);
  }
};

const secretObj = { secret: 'hidden', reveal: 'nothing' };
const proxy = new Proxy(secretObj, handler);

console.log(proxy.secret);

function recursiveReverseString(str) {
  return str === "" ? str : recursiveReverseString(str.substr(1)) + str[0];
}

const result = recursiveReverseString("hello");

console.log(result);

const products = [
  { id: 1, name: 'Laptop', price: 1200, category: 'Electronics' },
  { id: 2, name: 'Headphones', price: 100, category: 'Electronics' },
  { id: 3, name: 'Book', price: 15, category: 'Books' },
  { id: 4, name: 'Shirt', price: 25, category: 'Clothing' },
  { id: 5, name: 'Coffee Mug', price: 10, category: 'Kitchen' }
];

const result = products
  .filter(p => p.price > 20)
  .map(p => ({ name: p.name, value: p.price * 0.9 }))
  .reduce((acc, item) => {
    acc.names.push(item.name);
    acc.total += item.value;
    return acc;
  }, { names: [], total: 0 });

console.log(result);

const x = [1, 2, 3];
const y = x;
y.push(4);
console.log(x);

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

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

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

function task1() {
  console.log('A');
  setTimeout(() => console.log('B'), 0);
  Promise.resolve().then(() => console.log('C'));
  Promise.resolve().then(() => setTimeout(() => console.log('D'), 0));
  Promise.resolve().then(() => console.log('E'));
  setTimeout(() => console.log('F'), 0);
  console.log('G');
}

task1();

const words = ['a', 'b', 'c'];
const result = words.concat(1, 2, 3);
console.log(result);

let elf = 'Estel';
function lapland (params) { console.log(elf);
let elf = 'Arwen';
}
lapland();

function* fibonacci() {
  let [a, b] = [0, 1];
  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}

const fib = fibonacci();

const result = [];
for (let i = 0; i < 4; i++) {
  result.push(fib.next().value);
}

const sum = result.reduce((total, num) => total + num, 0);
console.log(sum);

const date = new Date('2023-05-15T12:30:00Z');  // A specific UTC date

const formatter = new Intl.DateTimeFormat('en-US', {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  hour: '2-digit',
  minute: '2-digit',
  timeZone: 'America/New_York'
});

const parts = formatter.formatToParts(date);
const month = parts.find(part => part.type === 'month').value;
const day = parts.find(part => part.type === 'day').value;
const hour = parts.find(part => part.type === 'hour').value;

console.log(`${month} ${day}, at ${hour}`);

const obj = { a: 1, b: 2, c: 3 };
let result = "";
for (const [key, value] of Object.entries(obj)) {
  result += key + value;
}
console.log(result);

console.log('Start');
setTimeout(() => console.log('Timeout 1'), 0);
setTimeout(() => console.log('Timeout 2'), 0);
console.log('End');

function processData(input) {
  try {
    if (typeof input !== 'string') {
      throw new TypeError('Input must be a string');
    }
    
    if (input.length === 0) {
      throw new Error('Input cannot be empty');
    }
    
    return input.toUpperCase();
  } catch (error) {
    if (error instanceof TypeError) {
      return `Type error: ${error.message}`;
    }
    return `Error: ${error.message}`;
  }
}

console.log(processData(''));

function recursivePalindromeCheck(str) {
  if (str.length <= 1) {
    return true;
  }

  return str[0] === str[str.length - 1] && recursivePalindromeCheck(str.slice(1, -1));
}

const result = recursivePalindromeCheck("radar");

console.log(result);

const user = {
  name: 'Alice',
  age: 30
};

const handler = {
  get(target, prop) {
    if (prop in target) {
      return target[prop];
    }
    return `Property '${prop}' doesn't exist`;
  },
  set(target, prop, value) {
    if (prop === 'age' && typeof value !== 'number') {
      console.log(`Error: ${value} is not a valid age`);
      return false;
    }
    target[prop] = value;
    return true;
  }
};

const userProxy = new Proxy(user, handler);
userProxy.age = '31';
userProxy.job = 'Developer';

console.log(userProxy.job);

const original = Object.freeze({ a: [1, 2, 3] });
const copy = { ...original };

copy.a.push(4);

console.log(original.a);
console.log(copy.a);

function process(data) {
  try {
    if (!data) {
      throw new TypeError('No data provided');
    }
    
    if (Array.isArray(data)) {
      return data.map(item => item * 2);
    }
    
    if (typeof data === 'object') {
      return Object.keys(data);
    }
    
    return data.toString();
  } catch (error) {
    if (error instanceof TypeError) {
      return 'Type error occurred';
    }
    return 'Unknown error';
  }
}

console.log(process(null));

var a = ( function a() {
   return '1';
},
function b() {
   return 2;
})()
alert(typeof a)