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

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 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 analyze(...items) {
  const [first, ...rest] = items;
  const { length } = [...rest, 'bonus'];
  const result = {
    ...first,
    count: length,
  };
  
  console.log(result);
}

analyze({ id: 42, name: 'Item' }, 'a', 'b');

const user = { id: 1, name: 'Alice' };
const userData = new WeakMap();

userData.set(user, { lastLogin: '2023-01-01' });
const clone = { ...user };

const originalData = userData.get(user);
const cloneData = userData.get(clone);

console.log(originalData, cloneData);