docs: function(module, exports, __webpack_require__) {
  
  	/**
  	 * Copyright 2013-present, Facebook, Inc.
  	 * All rights reserved.
  	 *
  	 * This source code is licensed under the BSD-style license found in the
  	 * LICENSE file in the root directory of this source tree. An additional grant
  	 * of patent rights can be found in the PATENTS file in the same directory.
  	 *
  	 */
  	
  	'use strict';
  	
  	var _prodInvariant = __webpack_require__(33),
  	    _assign = __webpack_require__(5);
  	
  	var ReactCompositeComponent = __webpack_require__(113);
  	var ReactEmptyComponent = __webpack_require__(117);
  	var ReactHostComponent = __webpack_require__(118);
  	
  	var getNextDebugID = __webpack_require__(119);
  	var invariant = __webpack_require__(9);
  	var warning = __webpack_require__(12);
  	
  	// To avoid a cyclic dependency, we create the final class in this module
  	var ReactCompositeComponentWrapper = function (element) {
  	  this.construct(element);
  	};
  	_assign(ReactCompositeComponentWrapper.prototype, ReactCompositeComponent, {
  	  _instantiateReactComponent: instantiateReactComponent
  	});
  	
  	function getDeclarationErrorAddendum(owner) {
  	  if (owner) {
  	    var name = owner.getName();
  	    if (name) {
  	      return ' Check the render method of `' + name + '`.';
  	    }
  	  }
  	  return '';
  	}
  	
  	/**
  	 * Check if the type reference is a known internal type. I.e. not a user
  	 * provided composite type.
  	 *
  	 * @param {function} type
  	 * @return {boolean} Returns true if this is a valid internal type.
  	 */
  	function isInternalComponentType(type) {
  	  return typeof type === 'function' && typeof type.prototype !== 'undefined' && typeof type.prototype.mountComponent === 'function' && typeof type.prototype.receiveComponent === 'function';
  	}
  	
  	/**
  	 * Given a ReactNode, create an instance that will actually be mounted.
  	 *
  	 * @param {ReactNode} node
  	 * @param {boolean} shouldHaveDebugID
  	 * @return {object} A new instance of the element's constructor.
  	 * @protected
  	 */
  	function instantiateReactComponent(node, shouldHaveDebugID) {
  	  var instance;
  	
  	  if (node === null || node === false) {
  	    instance = ReactEmptyComponent.create(instantiateReactComponent);
  	  } else if (typeof node === 'object') {
  	    var element = node;
  	    var type = element.type;
  	    if (typeof type !== 'function' && typeof type !== 'string') {
  	      var info = '';
  	      if (false) {
  	        if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
  	          info += ' You likely forgot to export your component from the file ' + 'it\'s defined in.';
  	        }
  	      }
  	      info += getDeclarationErrorAddendum(element._owner);
  	       true ?  false ? invariant(false, 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s', type == null ? type : typeof type, info) : _prodInvariant('130', type == null ? type : typeof type, info) : void 0;
  	    }
  	
  	    // Special case string values
  	    if (typeof element.type === 'string') {
  	      instance = ReactHostComponent.createInternalComponent(element);
  	    } else if (isInternalComponentType(element.type)) {
  	      // This is temporarily available for custom components that are not string
  	      // representations. I.e. ART. Once those are updated to use the string
  	      // representation, we can drop this code path.
  	      instance = new element.type(element);
  	
  	      // We renamed this. Allow the old name for compat. :(
  	      if (!instance.getHostNode) {
  	        instance.getHostNode = instance.getNativeNode;
  	      }
  	    } else {
  	      instance = new ReactCompositeComponentWrapper(element);
  	    }
  	  } else if (typeof node === 'string' || typeof node === 'number') {
  	    instance = ReactHostComponent.createInstanceForText(node);
  	  } else {
  	     true ?  false ? invariant(false, 'Encountered invalid React node of type %s', typeof node) : _prodInvariant('131', typeof node) : void 0;
  	  }
  	
  	  if (false) {
  	    process.env.NODE_ENV !== 'production' ? warning(typeof instance.mountComponent === 'function' && typeof instance.receiveComponent === 'function' && typeof instance.getHostNode === 'function' && typeof instance.unmountComponent === 'function', 'Only React Components can be mounted.') : void 0;
  	  }
  	
  	  // These two fields are used by the DOM and ART diffing algorithms
  	  // respectively. Instead of using expandos on components, we should be
  	  // storing the state needed by the diffing algorithms elsewhere.
  	  instance._mountIndex = 0;
  	  instance._mountImage = null;
  	
  	  if (false) {
  	    instance._debugID = shouldHaveDebugID ? getNextDebugID() : 0;
  	  }
  	
  	  // Internal instances should fully constructed at this point, so they should
  	  // not get any new fields added to them at this point.
  	  if (false) {
  	    if (Object.preventExtensions) {
  	      Object.preventExtensions(instance);
  	    }
  	  }
  	
  	  return instance;
  	}
  	
  	module.exports = instantiateReactComponent;
  
  /***/ }