docs: function() {
                      can.Construct.setup.apply(this, arguments);
  
                      // When `can.Component.setup` function is ran for the first time, `can.Component` doesn't exist yet 
                      // which ensures that the following code is ran only in constructors that extend `can.Component`. 
                      if (can.Component) {
                          var self = this,
                              scope = this.prototype.scope;
  
                          // Define a control using the `events` prototype property.
                          this.Control = ComponentControl.extend(this.prototype.events);
  
                          // Look to convert `scope` to a Map constructor function.
                          if (!scope || (typeof scope === "object" && !(scope instanceof can.Map))) {
                              // If scope is an object, use that object as the prototype of an extended 
                              // Map constructor function.
                              // A new instance of that Map constructor function will be created and
                              // set a the constructor instance's scope.
                              this.Map = can.Map.extend(scope || {});
                          } else if (scope.prototype instanceof can.Map) {
                              // If scope is a can.Map constructor function, just use that.
                              this.Map = scope;
                          }
  
                          // Look for default `@` values. If a `@` is found, these
                          // attributes string values will be set and 2-way bound on the
                          // component instance's scope.
                          this.attributeScopeMappings = {};
                          can.each(this.Map ? this.Map.defaults : {}, function(val, prop) {
                              if (val === "@") {
                                  self.attributeScopeMappings[prop] = prop;
                              }
                          });
  
                          // Convert the template into a renderer function.
                          if (this.prototype.template) {
                              // If `this.prototype.template` is a function create renderer from it by
                              // wrapping it with the anonymous function that will pass it the arguments,
                              // otherwise create the render from the string
                              if (typeof this.prototype.template === "function") {
                                  var temp = this.prototype.template;
                                  this.renderer = function() {
                                      return can.view.frag(temp.apply(null, arguments));
                                  };
                              } else {
                                  this.renderer = can.view.mustache(this.prototype.template);
                              }
                          }
  
                          // Register this component to be created when its `tag` is found.
                          can.view.tag(this.prototype.tag, function(el, options) {
                              new self(el, options);
                          });
                      }
  
                  }