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

function* take(iterable, limit) {
  for (const item of iterable) {
    if (limit <= 0) return;
    yield item;
    limit--;
  }
}

const fibs = [...take(fibonacci(), 5)];
fibs.push(fibs[0] + fibs[1]);
console.log(fibs);

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

const user = {
  profile: {
    name: 'Alice',
    social: null,
    getDetails() {
      return { verified: true };
    }
  }
};

const result = [
  user?.profile?.name,
  user?.profile?.social?.handle,
  user.profile.getDetails?.()?.verified,
  user?.nonExistent?.property
];

console.log(result);

function Vehicle(type) {
  this.type = type;
}

Vehicle.prototype.getType = function() {
  return this.type;
};

function Car(make) {
  this.make = make;
}

Car.prototype = Object.create(Vehicle.prototype);
Car.prototype.constructor = Car;

const myCar = new Car('Tesla');
myCar.type = 'electric';

console.log(myCar.getType(), myCar instanceof Vehicle, myCar.constructor.name);

const target = { a: 1, b: 2 };
const handler = {
  get(obj, prop) {
    return prop in obj ? obj[prop] * 2 : 'Not found';
  }
};

const proxy = new Proxy(target, handler);

// Add a property to the original target
target.c = 3;

// Attempt to access properties through proxy and Reflect
console.log([
  proxy.a,
  proxy.z,
  Reflect.get(target, 'b'),
  Reflect.get(proxy, 'c')
]);

type User = {
  id: number;
  name: string;
  role?: 'admin' | 'user';
};

function processUser(user: Partial<User>): string {
  const defaultUser: User = {
    id: 0,
    name: 'Guest',
    role: 'user'
  };
  
  const mergedUser = { ...defaultUser, ...user };
  
  if (mergedUser.role === 'admin') {
    return `Admin: ${mergedUser.name}`;
  }
  
  return `User: ${mergedUser.name} (ID: ${mergedUser.id})`;
}

console.log(processUser({ name: 'John', role: 'admin' }));

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