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 EventPluginHub = __webpack_require__(40);
  	var EventPluginUtils = __webpack_require__(42);
  	
  	var accumulateInto = __webpack_require__(44);
  	var forEachAccumulated = __webpack_require__(45);
  	var warning = __webpack_require__(12);
  	
  	var getListener = EventPluginHub.getListener;
  	
  	/**
  	 * Some event types have a notion of different registration names for different
  	 * "phases" of propagation. This finds listeners by a given phase.
  	 */
  	function listenerAtPhase(inst, event, propagationPhase) {
  	  var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
  	  return getListener(inst, registrationName);
  	}
  	
  	/**
  	 * Tags a `SyntheticEvent` with dispatched listeners. Creating this function
  	 * here, allows us to not have to bind or create functions for each event.
  	 * Mutating the event's members allows us to not have to create a wrapping
  	 * "dispatch" object that pairs the event with the listener.
  	 */
  	function accumulateDirectionalDispatches(inst, phase, event) {
  	  if (false) {
  	    process.env.NODE_ENV !== 'production' ? warning(inst, 'Dispatching inst must not be null') : void 0;
  	  }
  	  var listener = listenerAtPhase(inst, event, phase);
  	  if (listener) {
  	    event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
  	    event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
  	  }
  	}
  	
  	/**
  	 * Collect dispatches (must be entirely collected before dispatching - see unit
  	 * tests). Lazily allocate the array to conserve memory.  We must loop through
  	 * each event and perform the traversal for each one. We cannot perform a
  	 * single traversal for the entire collection of events because each event may
  	 * have a different target.
  	 */
  	function accumulateTwoPhaseDispatchesSingle(event) {
  	  if (event && event.dispatchConfig.phasedRegistrationNames) {
  	    EventPluginUtils.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
  	  }
  	}
  	
  	/**
  	 * Same as `accumulateTwoPhaseDispatchesSingle`, but skips over the targetID.
  	 */
  	function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
  	  if (event && event.dispatchConfig.phasedRegistrationNames) {
  	    var targetInst = event._targetInst;
  	    var parentInst = targetInst ? EventPluginUtils.getParentInstance(targetInst) : null;
  	    EventPluginUtils.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
  	  }
  	}
  	
  	/**
  	 * Accumulates without regard to direction, does not look for phased
  	 * registration names. Same as `accumulateDirectDispatchesSingle` but without
  	 * requiring that the `dispatchMarker` be the same as the dispatched ID.
  	 */
  	function accumulateDispatches(inst, ignoredDirection, event) {
  	  if (event && event.dispatchConfig.registrationName) {
  	    var registrationName = event.dispatchConfig.registrationName;
  	    var listener = getListener(inst, registrationName);
  	    if (listener) {
  	      event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
  	      event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
  	    }
  	  }
  	}
  	
  	/**
  	 * Accumulates dispatches on an `SyntheticEvent`, but only for the
  	 * `dispatchMarker`.
  	 * @param {SyntheticEvent} event
  	 */
  	function accumulateDirectDispatchesSingle(event) {
  	  if (event && event.dispatchConfig.registrationName) {
  	    accumulateDispatches(event._targetInst, null, event);
  	  }
  	}
  	
  	function accumulateTwoPhaseDispatches(events) {
  	  forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
  	}
  	
  	function accumulateTwoPhaseDispatchesSkipTarget(events) {
  	  forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
  	}
  	
  	function accumulateEnterLeaveDispatches(leave, enter, from, to) {
  	  EventPluginUtils.traverseEnterLeave(from, to, accumulateDispatches, leave, enter);
  	}
  	
  	function accumulateDirectDispatches(events) {
  	  forEachAccumulated(events, accumulateDirectDispatchesSingle);
  	}
  	
  	/**
  	 * A small set of propagation patterns, each of which will accept a small amount
  	 * of information, and generate a set of "dispatch ready event objects" - which
  	 * are sets of events that have already been annotated with a set of dispatched
  	 * listener functions/ids. The API is designed this way to discourage these
  	 * propagation strategies from actually executing the dispatches, since we
  	 * always want to collect the entire set of dispatches before executing event a
  	 * single one.
  	 *
  	 * @constructor EventPropagators
  	 */
  	var EventPropagators = {
  	  accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,
  	  accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,
  	  accumulateDirectDispatches: accumulateDirectDispatches,
  	  accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
  	};
  	
  	module.exports = EventPropagators;
  
  /***/ }