const user = { name: 'Alice' };
const ratings = new WeakMap();

ratings.set(user, 5);
const result = [];

result.push(ratings.has(user));
result.push(ratings.get(user));

// Create a reference-free object
let tempUser = { name: 'Bob' };
ratings.set(tempUser, 10);
result.push(ratings.has(tempUser));

// Remove the reference
tempUser = null;

// Try to iterate through WeakMap
result.push(typeof ratings[Symbol.iterator]);

console.log(result);

function Shape() {}

function Circle(radius) {
  this.radius = radius;
}

Circle.prototype = Object.create(Shape.prototype);
Circle.prototype.constructor = Circle;

const shape = new Shape();
const circle = new Circle(5);

console.log(circle instanceof Circle);
console.log(circle instanceof Shape);
console.log(shape instanceof Circle);
console.log(shape instanceof Shape);

function recursiveFibonacci(n) {
  return n <= 1 ? n : recursiveFibonacci(n - 1) + recursiveFibonacci(n - 2);
}

const result = recursiveFibonacci(6);

console.log(result);

function processTransaction(amount) {
  try {
    if (typeof amount !== 'number') {
      throw new TypeError('Amount must be a number');
    }
    if (amount <= 0) {
      throw new RangeError('Amount must be positive');
    }
    return 'Transaction processed';
  } catch (error) {
    if (error instanceof TypeError) {
      return { status: 'Type Error', message: error.message };
    } else if (error instanceof RangeError) {
      return { status: 'Range Error', message: error.message };
    }
    return { status: 'Unknown Error', message: error.message };
  }
}

console.log(processTransaction(-50));

const arr = [1, 2, 3];
arr[-1] = 10;
console.log(arr.length, arr);

for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100);
}

function modify(obj) {
  obj.a.push(4);
  obj.b = 'changed';
  return obj;
}

const original = { a: [1, 2, 3], b: 'original', c: { deep: true } };
const copy1 = { ...original };
const copy2 = JSON.parse(JSON.stringify(original));

modify(copy1);
console.log(original.a, original.b, copy2.c === original.c);

const obj = Object.freeze({
  a: [1, 2, 3],
  b: {
    c: 4
  }
});

obj.a.push(4);
obj.b.c = 5;

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

const result = (function() {
  let count = 0;
  
  return {
    increment() {
      return ++count;
    },
    get value() {
      return count;
    },
    reset() {
      const oldCount = count;
      count = 0;
      return oldCount;
    }
  };
})();

result.increment();
result.increment();
console.log(result.reset() + result.value + result.increment());

const weakMap = new WeakMap();
const arr = [1, 2, 3].map(n => ({ n }));

arr.forEach(obj => weakMap.set(obj, obj.n * 2));

arr.pop(); // Remove the last element

const result = arr.reduce((acc, obj) => acc + weakMap.get(obj), 0);

console.log(result);

const range = Array.from({ length: 5 }, (_, index) =>
index + 1);
console.log(range);

const weakMap = new WeakMap();
const gen = (function* () {
  yield { key: 'value1' };
  yield { key: 'value2' };
})();

const obj1 = gen.next().value;
const obj2 = gen.next().value;

weakMap.set(obj1, 'stored value1');
weakMap.set(obj2, 'stored value2');

const result = [...gen].map(obj => weakMap.get(obj));

console.log(result);

const a = [1, 2, 3, 4];
console.log(a + "");

try {
  const arr = [1, 2, 3];
  
  function processArray() {
    try {
      nonExistentFunction();
    } catch (err) {
      throw new TypeError('Invalid type');
    }
  }
  
  try {
    processArray();
  } catch (err) {
    console.log(err instanceof Error, err instanceof TypeError, err.message);
  }
} catch (finalError) {
  console.log('Caught in outer block:', finalError);
}

const arr = [];
arr.length = 3;
arr[2] = 1;
arr.forEach((el, i) => console.log(i))

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 obj = {};
let value = 0;

Object.defineProperty(obj, 'prop', {
  get() {
    return value;
  },
  set(newValue) {
    value = newValue + 1;
  },
  configurable: true,
  enumerable: true
});

obj.prop = 10;
console.log(obj.prop);

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 property to original object
target.c = 3;

// Modify existing property directly on proxy
proxy.a = 10;

// Use Reflect.get instead of direct property access
const result = Reflect.get(proxy, 'd', { custom: true });

console.log(proxy.a, proxy.b, proxy.c, result);

function* generator1() {
  yield 1;
  yield 2;
}

function* generator2() {
  yield* generator1();
  yield 3;
}

const gen = generator2();
console.log(gen.next().value);
console.log(gen.next().value);
console.log(gen.next().value);

function* gen() {
  yield 1;
  yield 2;
  yield 3;
}

async function asyncFunc() {
  for (let value of gen()) {
    await new Promise(res => setTimeout(res, 100));
    console.log(value);
  }
  return 'done';
}

const result = asyncFunc();
console.log(result instanceof Promise);