Agreed. The following line of code breaks self-encapsulation:

    this._currentBalance = this._currentBalance - cheque.amount();

"In JavaScript (and other languages in the same family), classes and subclasses share access to the object’s private properties."

Self-encapsulation ensures internal variables are only directly referenced twice: via accessors. This adheres to the DRY principle. The above line should be written:

    balance( balance() - cheque.amount() );

Or more explicitly as:

    setBalance( getBalance() - cheque.amount() );

Even if the superclass is later modified to use a transaction history, which would violate the Open-Closed Principle, the subclasses would continue to function correctly. (The transaction history would be implemented inside the accessors, making the additional code transparent to subclasses.)

Source code that eschews self-encapsulation will be brittle. Developers must grok the DRY principle. Code that directly sets or retrieves internal variable values in more than two places should be refactored to eliminate the duplication.

Also, the Account class is incomplete. The Account class should have a withdraw method to mirror the deposit method. The ChequingAccount would overload the Account's withdraw method to take a cheque object, such as:

    ChequingAccount.prototype.withdraw = function (money) {
      super.withdraw( money typeof Cheque ? money.amount() : money );
      return this;
    }

I am unfamiliar with the JavaScript OO syntax to call the superclass, but this revised design is otherwise sound. In this way, the parent class can vary its account balance implementation (e.g., introduce a transaction history) without affecting its children.