* Get object describing the nodes which contain characters at offset. * * @param {DOMElement|DOMTextNode} root * @param {number} offset * @return

* Drill down (through composites and empty components) until we get a host or * host text component. * * This is pretty polymorphic but unavoidable

* Gets the key used to access text content on a DOM node. * * @return {?string} Key used to access text content. * @internal

* True if the supplied DOM node has a direct React-rendered child that is * not a React root element. Useful for warning in `render`, * `unmountComp

* While `isCollapsed` is available on the Selection object and `collapsed` * is available on the Range object, IE11 sometimes gets them wrong. * If

* Does our fallback mode think that this event is the end of composition? * * @param {string} topLevelType * @param {object} nativeEvent * @return

* @param {*} object The object to check. * @return {boolean} Whether or not the object is a DOM text node.

* @param {?object} object * @return {boolean} True if `object` is a valid owner. * @final

* Merge two objects, but throw if both contain the same key. * * @param {object} one The first object, which is mutated. * @param {object} tw

* Populate `_hostNode` on each child of `inst`, assuming that the children * match up with the DOM (element) children of `node`. * * We cache entir

* 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

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

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

* 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 * w

* 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 * reordered.

* 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 * r

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

* 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 * @return

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

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

* Checks if a given DOM node contains or is another DOM node.

* 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. * * Thi

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

* Creates an array containing the nodes rendered from the supplied markup. The * optionally supplied `handleScript` function will be invoked once for

* Escape special characters in the given string of html. * * @param {string} string The string to escape for inserting into HTML * @return {string

* 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 SyntheticInpu

* @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 each

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

* @param {function} traverseContext Context passed through traversal. * @param {?ReactComponent} child React child component. * @param {!string} nam

* 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} topL

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

* Gets the markup wrap configuration for the supplied `nodeName`. * * NOTE: This lazily detects which wraps are necessary for the current browser.

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

* Extracts the `nodeName` of the first element in a string of markup. * * @param {string} markup String of markup. * @return {?string} Node name of

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

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

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

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

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