code: function (base) {
  		var defaults = base.defaults ? canReflect.serialize(base.defaults) : {};
  		this.defaults = canReflect.assignDeepMap(defaults,this.defaults);
  	}
docs: Set `defaults` as the merger of the parent `defaults` and this object's `defaults`. If you overwrite this method, make sure to include option merging logic. 
  @function can-construct.setup setup
  @parent can-construct.static
  
  @description Perform initialization logic for a constructor function.
  
  @signature `Construct.setup(base, fullName, staticProps, protoProps)`
  
  A static `setup` method provides inheritable setup functionality
  for a Constructor function. The following example
  creates a Group constructor function.  Any constructor
  functions that inherit from Group will be added to
  `Group.childGroups`.
  
  ```js
  Group = Construct.extend({
  setup: function(Construct, fullName, staticProps, protoProps){
  this.childGroups = [];
  if(Construct !== Construct){
  this.childGroups.push(Construct)
  }
  Construct.setup.apply(this, arguments)
  }
  },{})
  var Flock = Group.extend(...)
  Group.childGroups[0] //-> Flock
  ```
  @param {constructor} base The base constructor that is being inherited from.
  @param {String} fullName The name of the new constructor.
  @param {Object} staticProps The static properties of the new constructor.
  @param {Object} protoProps The prototype properties of the new constructor.
  
  @body
  The static `setup` method is called immediately after a constructor
  function is created and
  set to inherit from its base constructor. It is useful for setting up
  additional inheritance work.
  Do not confuse this with the prototype `[can-construct::setup]` method.
  
  ## Example
  
  This `Parent` class adds a reference to its base class to itself, and
  so do all the classes that inherit from it.
  
  ```js
  Parent = Construct.extend({
  setup : function(base, fullName, staticProps, protoProps){
  this.base = base;
  
  // call base functionality
  Construct.setup.apply(this, arguments)
  }
  },{});
  
  Parent.base; // Construct
  
  Child = Parent({});
  
  Child.base; // Parent
  ```