docs: function(fullName, klass, proto) {
                      // Figure out what was passed and normalize it.
                      if (typeof fullName !== 'string') {
                          proto = klass;
                          klass = fullName;
                          fullName = null;
                      }
                      if (!proto) {
                          proto = klass;
                          klass = null;
                      }
                      proto = proto || {};
                      var _super_class = this,
                          _super = this.prototype,
                          parts, current, _fullName, _shortName, name, shortName, namespace, prototype;
                      // Instantiate a base class (but only create the instance,
                      // don't run the init constructor).
                      prototype = this.instance();
                      // Copy the properties over onto the new prototype.
                      can.Construct._inherit(proto, _super, prototype);
                      // The dummy class constructor.
  
                      function Constructor() {
                          // All construction is actually done in the init method.
                          if (!initializing) {
  
  
                              return this.constructor !== Constructor &&
                              // We are being called without `new` or we are extending.
                              arguments.length && Constructor.constructorExtends ? Constructor.extend.apply(Constructor, arguments) :
                              // We are being called with `new`.
                              Constructor.newInstance.apply(Constructor, arguments);
                          }
                      }
                      // Copy old stuff onto class (can probably be merged w/ inherit)
                      for (name in _super_class) {
                          if (_super_class.hasOwnProperty(name)) {
                              Constructor[name] = _super_class[name];
                          }
                      }
                      // Copy new static properties on class.
                      can.Construct._inherit(klass, _super_class, Constructor);
                      // Setup namespaces.
                      if (fullName) {
  
                          parts = fullName.split('.');
                          shortName = parts.pop();
                          current = can.getObject(parts.join('.'), window, true);
                          namespace = current;
                          _fullName = can.underscore(fullName.replace(/\./g, "_"));
                          _shortName = can.underscore(shortName);
  
  
  
                          current[shortName] = Constructor;
                      }
                      // Set things that shouldn't be overwritten.
                      can.extend(Constructor, {
                              constructor: Constructor,
                              prototype: prototype,
  
                              namespace: namespace,
  
                              _shortName: _shortName,
  
                              fullName: fullName,
                              _fullName: _fullName
                          });
                      // Dojo and YUI extend undefined
                      if (shortName !== undefined) {
                          Constructor.shortName = shortName;
                      }
                      // Make sure our prototype looks nice.
                      Constructor.prototype.constructor = Constructor;
                      // Call the class `setup` and `init`
                      var t = [_super_class].concat(can.makeArray(arguments)),
                          args = Constructor.setup.apply(Constructor, t);
                      if (Constructor.init) {
                          Constructor.init.apply(Constructor, args || t);
                      }
  
                      return Constructor;
                  }