function processConfig(config) {
  const settings = {
    timeout: config.timeout ?? 1000,
    retries: config.retries ?? 3,
    logging: config.logging ?? false,
    debug: config.debug || true
  };
  
  return settings;
}

const userConfig = {
  timeout: 0,
  retries: null,
  logging: false,
  debug: false
};

console.log(processConfig(userConfig));

const createMathOps = (base) => {
  return {
    add: (x) => base + x,
    multiply: (x) => base * x
  };
};

const createAdvancedMathOps = (base) => {
  const basicOps = createMathOps(base);
  return {
    ...basicOps,
    square: () => basicOps.multiply(base),
    addThenSquare: (x) => {
      const added = basicOps.add(x);
      return added * added;
    }
  };
};

const calculator = createAdvancedMathOps(5);
console.log(calculator.addThenSquare(3));

const obj = { name: 'Alice', age: 30 };  
const handler = {
  get(target, prop) {
    return prop in target ? target[prop] : `Property '${prop}' doesn't exist`;
  }
};

const proxy = new Proxy(obj, handler);

const descriptors = Object.getOwnPropertyDescriptors(obj);
Reflect.defineProperty(obj, 'city', {
  value: 'New York',
  enumerable: false
});

console.log(proxy.city, proxy.country);

const text = 'Today is 2023-12-31 and tomorrow is 2024-01-01';
const dateRegex = /(\d{4})-(\d{2})-(\d{2})/g;

let result = '';
let match;

while ((match = dateRegex.exec(text)) !== null) {
  const [fullMatch, year, month, day] = match;
  result += `${day}/${month}/${year.slice(2)} `;
}

console.log(result.trim());

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

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

function outer() {
  console.log(typeof inner);
  console.log(typeof inner2);
  
  var inner = function() {
    return 'Inside inner';
  };
  
  function inner2() {
    return 'Inside inner2';
  }
  
  console.log(typeof inner);
  console.log(typeof inner2);
}

outer();

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

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

console.log(result);

const cache = new WeakMap();

const user1 = { name: 'Alice' };
const user2 = { name: 'Bob' };

cache.set(user1, { lastLogin: 'yesterday' });
cache.set(user2, { lastLogin: 'today' });

const result = [];
result.push(cache.has(user1));
result.push(cache.get(user2).lastLogin);

let user3 = { name: 'Charlie' };
cache.set(user3, { lastLogin: 'now' });
result.push(cache.has(user3));

user3 = null; // Removing the reference
// Garbage collector might run here in real situations

const user4 = { name: 'Charlie' }; // Same name, different object
result.push(cache.has(user4));

console.log(result);

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