docs: function $super(arrayOfArgs) {
        // since we are thunking a method call, performance is important here: 
        // memoize all lookups, once memoized the fast path calls no other 
        // functions
        //
        // find the caller (cannot be `strict` because of 'caller')
        var caller = $super.caller;
        // memoized 'name of method' 
        var nom = caller.nom;
        // memoized next implementation prototype
        var _super = caller._super;
        if (!_super) {
          if (!nom) {
            nom = caller.nom = nameInThis.call(this, caller);
          }
          if (!nom) {
            console.warn('called super() on a method not installed declaratively (has no .nom property)');
          }
          // super prototype is either cached or we have to find it
          // by searching __proto__ (at the 'top')
          // invariant: because we cache _super on fn below, we never reach 
          // here from inside a series of calls to super(), so it's ok to 
          // start searching from the prototype of 'this' (at the 'top')
          // we must never memoize a null super for this reason
          _super = memoizeSuper(caller, nom, getPrototypeOf(this));
        }
        // our super function
        var fn = _super[nom];
        if (fn) {
          // memoize information so 'fn' can call 'super'
          if (!fn._super) {
            // must not memoize null, or we lose our invariant above
            memoizeSuper(fn, nom, _super);
          }
          // invoke the inherited method
          // if 'fn' is not function valued, this will throw
          return fn.apply(this, arrayOfArgs || []);
        }
      }