* Publishes a registration name that is used to identify dispatched events and * can be used with `EventPluginHub.putListener` to register listeners

* Recomputes the plugin list using the injected plugins and plugin ordering. * * @private

* Performs equality by iterating through keys on an object and returning false * when any key has values which are not strictly equal between the ar

* (For IE <=11) Removes the event listeners from the currently-tracked element, * if any exists.

* Ensure that every element either is passed in a static location, in an * array with an explicit keys property defined, or in an object literal *

* Warn if the element doesn't have an explicit key assigned to it. * This element is in an array. The array could grow and shrink or be * reordere

* Given an element, validate that its props follow the propTypes definition, * provided by the type. * * @param {ReactElement} element

* Accumulates without regard to direction, does not look for phased * registration names. Same as `accumulateDirectDispatchesSingle` but without *

* Binds a method to the component. * * @param {object} component Component whose method is going to be bound. * @param {function} method Method

* Binds all auto-bound methods in a component. * * @param {object} component Component whose method is going to be bound.

* Camelcases a hyphenated string, for example: * * > camelize('background-color') * < "backgroundColor" * * @param {string} string * @

* Camelcases a hyphenated CSS property name, for example: * * > camelizeStyleName('background-color') * < "backgroundColor" * > camelize

* Assert that the props are valid * * @param {string} componentName Name of the component for error messages. * @param {object} propTypes Map of

* Validation function for `value` and `defaultValue`. * @private

* Checks if a given DOM node contains or is another DOM node. * * @param {?DOMNode} outerNode Outer DOM node. * @param {?DOMNode} innerNode Inne

* Ensure that the argument is an array by wrapping it in an array if it is not. * Creates a copy of the argument if it is already an array. * *

* Creates a function that invokes two functions and ignores their return vales. * * @param {function} one Function to invoke first. * @param {fu

* Standard/simple iteration through an event's collected dispatches, but stops * at the first dispatch execution returning true, and returns that id

* Extract a SyntheticInputEvent for `beforeInput`, based on either native * `textInput` or fallback behavior. * * @return {?object} A SyntheticI

* @return {?object} A SyntheticCompositionEvent.

* Find the deepest React component completely containing the root of the * passed-in instance (for use when entire React trees are nested within eac

* Finds the index of the first character * that's not common between the two given strings. * * @return {number} the index of the character wher

* Shared warning and monitoring code for the key warnings. * * @internal * @param {string} messageType A key used for de-duping warnings. * @p

* Given a DOM node, return the closest ReactDOMComponent or * ReactDOMTextComponent instance ancestor.

* Translate native top level events into event types. * * @param {string} topLevelType * @return {object}

* For browsers that do not provide the `textInput` event, extract the * appropriate string to use for SyntheticInputEvent. * * @param {string} t

* Return the lowest common ancestor of A and B, or null if they are in * different trees.

* @param {string} topLevelType Record from `EventConstants`. * @param {object} nativeEvent Native browser event. * @return {?string} The string co

* Get an object which is a unique representation of the current selection. * * The return value will not be consistent across nodes or browsers, b

* Get the next sibling within a container. This will walk up the * DOM if a node's siblings have been exhausted. * * @param {DOMElement|DOMTextN

* Gets the scroll position of the supplied element or window. * * The return values are unbounded, unlike `getScrollPosition`. This means they *

* Perform a heuristic test to determine if an object is "array-like". * * A monk asked Joshu, a Zen master, "Has a dog Buddha nature?" * Jos

* Hyphenates a camelcased string, for example: * * > hyphenate('backgroundColor') * < "background-color" * * For CSS style names, use `h

* Hyphenates a camelcased CSS property name, for example: * * > hyphenateStyleName('backgroundColor') * < "background-color" * > hyphena

* Does our fallback best-guess model think this event signifies that * composition has begun? * * @param {string} topLevelType * @param {objec

* Check if the type reference is a known internal type. I.e. not a user * provided composite type. * * @param {function} type * @return {boole

* Return whether a native keypress event is assumed to be a command. * This is required because Firefox fires `keypress` events for key commands *

* Opera <= 12 includes TextEvent in window, but does not fire * text input events. Rely on keypress instead.

* Some event types have a notion of different registration names for different * "phases" of propagation. This finds listeners by a given phase.

* Make an update for markup to be rendered and inserted at a supplied index. * * @param {string} markup Markup that renders into an element. * @

* Make an update for moving an existing element to another index. * * @param {number} fromIndex Source index of the existing element. * @param {

* Make an update for removing an element at an index. * * @param {number} fromIndex Index of the element to remove. * @private

* Make an update for setting the markup of a node. * * @param {string} markup Markup that renders into an element. * @private

* Make an update for setting the text content. * * @param {string} textContent Text content to set. * @private

* Executes the provided `callback` once for each enumerable own property in the * object and constructs a new object from the results. The `callback

* Memoizes the return value of a function that accepts one string argument. * * @param {function} callback * @return {function}

* Populate `_nativeNode` on the rendered native/text component with the given * DOM node. The passed `inst` can be a composite.

* @param {string} prefix vendor-specific prefix, eg: Webkit * @param {string} key style name, eg: transitionDuration * @return {string} style name

* Publishes an event so that it can be dispatched by the supplied plugin. * * @param {object} dispatchConfig Dispatch configuration for the event.

* SECTION: handle `change` event

* SECTION: handle `click` event

* (For IE <=11) Starts tracking propertychange events on the passed-in element * and override the value property so that we can distinguish user eve

* Flatten a children object (typically specified as `props.children`) and * return an array with appropriately re-keyed children.

* @param {?*} children Children tree container. * @param {!string} nameSoFar Name of the key path so far. * @param {!function} callback Callback t

* Unescape and unwrap key for human-readable display * * @param {string} key to unescape. * @return {string} the unescaped key.

* A specialized pseudo-event module to help keep track of components waiting to * be notified when their DOM representations are available for use.