no-param-reassign eslint rule. 
Can you show an example why this rule is useful
The `no-param-reassign` rule in ESLint is designed to prevent the reassignment of function parameters. This rule is useful for several reasons:

1. **Clarity**: Reassigning parameters can make the code less readable and harder to understand, as it can be unclear whether the original value of the parameter is still needed or if it has been changed.

2. **Side Effects**: If parameters are reassigned, it can lead to unintended side effects, especially if the parameter is an object or an array that is passed by reference. This can cause bugs that are difficult to trace.

3. **Immutability**: Encouraging the use of immutability can lead to more predictable code. By not allowing parameter reassignment, it promotes practices that avoid mutation, which can lead to fewer bugs.

### Example

Here’s an example to illustrate the usefulness of the `no-param-reassign` rule:

#### Without `no-param-reassign`

```javascript
function updateUser(user) {
    user.name = 'Alice'; // Mutating the user object
    user = { ...user, age: 30 }; // Reassigning the parameter
    return user;
}

const originalUser = { name: 'Bob', age: 25 };
const updatedUser = updateUser(originalUser);
console.log(originalUser); // { name: 'Alice', age: 25 } - original object is mutated
console.log(updatedUser); // { name: 'Alice',
no-param-reassign eslint rule. 
Can you show an example why this rule is useful?

Sure! Here's an example where the `no-param-reassign` rule could help prevent unexpected behavior:

```javascript
function double(arr) {
  arr.forEach(item => item * 2);
  return arr;
}

const numbers = [1, 2, 3];
console.log(double(numbers)); // [2, 4, 6]

// However, this function unintentionally modifies the original array:
numbers.forEach(item => item * 2);
console.log(numbers); // [2, 4, 6]
```

In the above example, the `double` function is supposed to return a new array with each element doubled. However, the `forEach` method also modifies the original array, which may not be intended. The `no-param-reassign` rule would warn about this issue. To fix it, you could use the `map` method instead:

```javascript
function double(arr) {
  return arr.map(item => item * 2);
}

const numbers = [1, 2, 3];
console.log(double(numbers)); // [2, 4, 6]

// The original array remains unchanged:
console.log(numbers); //