docs: function mixSpecIntoComponent(Constructor, spec) {
  	  if (!spec) {
  	    if (false) {
  	      var typeofSpec = typeof spec;
  	      var isMixinValid = typeofSpec === 'object' && spec !== null;
  	
  	      process.env.NODE_ENV !== 'production' ? warning(isMixinValid, '%s: You\'re attempting to include a mixin that is either null ' + 'or not an object. Check the mixins included by the component, ' + 'as well as any mixins they include themselves. ' + 'Expected object but got %s.', Constructor.displayName || 'ReactClass', spec === null ? null : typeofSpec) : void 0;
  	    }
  	
  	    return;
  	  }
  	
  	  !(typeof spec !== 'function') ?  false ? invariant(false, 'ReactClass: You\'re attempting to use a component class or function as a mixin. Instead, just use a regular object.') : _prodInvariant('75') : void 0;
  	  !!ReactElement.isValidElement(spec) ?  false ? invariant(false, 'ReactClass: You\'re attempting to use a component as a mixin. Instead, just use a regular object.') : _prodInvariant('76') : void 0;
  	
  	  var proto = Constructor.prototype;
  	  var autoBindPairs = proto.__reactAutoBindPairs;
  	
  	  // By handling mixins before any other properties, we ensure the same
  	  // chaining order is applied to methods with DEFINE_MANY policy, whether
  	  // mixins are listed before or after these methods in the spec.
  	  if (spec.hasOwnProperty(MIXINS_KEY)) {
  	    RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);
  	  }
  	
  	  for (var name in spec) {
  	    if (!spec.hasOwnProperty(name)) {
  	      continue;
  	    }
  	
  	    if (name === MIXINS_KEY) {
  	      // We have already handled mixins in a special case above.
  	      continue;
  	    }
  	
  	    var property = spec[name];
  	    var isAlreadyDefined = proto.hasOwnProperty(name);
  	    validateMethodOverride(isAlreadyDefined, name);
  	
  	    if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {
  	      RESERVED_SPEC_KEYS[name](Constructor, property);
  	    } else {
  	      // Setup methods on prototype:
  	      // The following member methods should not be automatically bound:
  	      // 1. Expected ReactClass methods (in the "interface").
  	      // 2. Overridden methods (that were mixed in).
  	      var isReactClassMethod = ReactClassInterface.hasOwnProperty(name);
  	      var isFunction = typeof property === 'function';
  	      var shouldAutoBind = isFunction && !isReactClassMethod && !isAlreadyDefined && spec.autobind !== false;
  	
  	      if (shouldAutoBind) {
  	        autoBindPairs.push(name, property);
  	        proto[name] = property;
  	      } else {
  	        if (isAlreadyDefined) {
  	          var specPolicy = ReactClassInterface[name];
  	
  	          // These cases should already be caught by validateMethodOverride.
  	          !(isReactClassMethod && (specPolicy === 'DEFINE_MANY_MERGED' || specPolicy === 'DEFINE_MANY')) ?  false ? invariant(false, 'ReactClass: Unexpected spec policy %s for key %s when mixing in component specs.', specPolicy, name) : _prodInvariant('77', specPolicy, name) : void 0;
  	
  	          // For methods which are defined more than once, call the existing
  	          // methods before calling the new property, merging if appropriate.
  	          if (specPolicy === 'DEFINE_MANY_MERGED') {
  	            proto[name] = createMergedResultFunction(proto[name], property);
  	          } else if (specPolicy === 'DEFINE_MANY') {
  	            proto[name] = createChainedFunction(proto[name], property);
  	          }
  	        } else {
  	          proto[name] = property;
  	          if (false) {
  	            // Add verbose displayName to the function, which helps when looking
  	            // at profiling tools.
  	            if (typeof property === 'function' && spec.displayName) {
  	              proto[name].displayName = spec.displayName + '_' + name;
  	            }
  	          }
  	        }
  	      }
  	    }
  	  }
  	}