Encapsulate state with the module pattern

Long before #private fields, the way to protect state was to keep it in a function's scope and return only the operations you wanted to allow. It is still the pattern behind most stores and SDK clients: the internals are unreachable, so every change goes through a method that can validate it.

Implement createAccount(initialBalance = 0). It returns an object with exactly four methods: deposit(amount) adds to the balance and returns the new balance; withdraw(amount) subtracts and returns the new balance; getBalance() returns the current balance; and getHistory() returns the recorded operations. The balance itself must not be an own property of the returned object, so its only own enumerable properties are those four methods. deposit and withdraw throw new Error("Invalid amount") when the amount is not greater than zero, and withdraw throws new Error("Insufficient funds") when the amount exceeds the balance; in both cases the balance is left unchanged and nothing is recorded. getHistory() returns a new array each time, holding one entry per successful operation in order, each of the form { type: "deposit", amount: 10 } or { type: "withdraw", amount: 5 } — mutating the returned array must not affect the account.

const account = createAccount(100);

account.deposit(50);  // 150
account.withdraw(30); // 120
account.getBalance(); // 120

const account = createAccount(20);
try { account.withdraw(50); } catch (e) { /* Insufficient funds */ }

account.getBalance(); // 20 — rejected operations leave state untouched
account.getHistory(); // [] — nothing was recorded