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

const map = new Map();
const weakMap = new WeakMap();

map.set(obj1, 'mapValue');
weakMap.set(obj2, 'weakMapValue');

obj1 = null;  // Changing reference
obj2 = null;  // Changing reference

console.log(map.has(obj1));
console.log(weakMap.has(obj2));

function* genFunc() {
  yield Symbol('A');
  yield new Function('return this')();
}

const obj = { key: genFunc().next().value };
obj.key = genFunc().next().value;

console.log(obj.key === globalThis);

const secret = 'hidden';
function revealSecret() {
  const secret = 'revealed';
  const obj = { secret: 'object secret' };
  with (obj) {
    return () => secret;
  }
}

const mySecret = revealSecret()();
console.log(mySecret);

const secretKey = Symbol('key');
const secretValue = 'secret';

function Store() {
  this[secretKey] = secretValue;
}

Store.prototype.get = function(key) {
  return this[key];
};

const store = new Store();
const revealed = store.get(secretKey);
console.log(revealed);

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

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* generator() {
  yield 1;
  yield 2;
}

const gen = generator();
const sym = Symbol('unique');

gen[sym] = function() {
  return this.next().value;
};

console.log(gen[sym](), gen[sym](), gen[sym]());

const func = new Function('a', 'b', 'return a + b');
console.log(func(1, 2));