* Processes any enqueued updates. * * @private

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

* 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

* Special handling for multiline string literals * print lines: * * line * line * * as: * * "line "+ * "line"

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

* Applies all available transformations to the source * @param {array} visitors * @param {string} source * @param {?object} options * @return {obj

* Ensure that every component either is passed in a static location or, if * if it's passed in an array, has an explicit key property defined. * *

* Find a node by ID. * * If your application code depends on the existence of the element, use $, * which will throw if the element doesn't exist.

* @param {object} node * @param {object} parentNode * @return {boolean}

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

* Between XJS opening and closing tags (e.g. <foo>HERE</foo>), anything that * is not another XJS tag and is not an expression wrapped by {} is t

* Checks whether a node or any of its sub-nodes contains * a syntactic construct of the passed type. * @param {object} node - AST node to test. * @

* Copy properties from one or more objects (up to 5) into the first object. * This is a shallow copy. It mutates the first object and also returns it

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

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

* Construct an object from an array of keys * and optionally specified value or list of values. * * >>> createObjectFrom(['a','b','c']); * {a: t

* A `state` object represents the state of the parser. It has "local" and * "global" parts. Global contains parser position, source, etc. Local conta

* Enqueues markup to be rendered and inserted at a supplied index. * * @param {string} parentID ID of the parent component. * @param {string} marku

* Enqueues moving an existing element to another index. * * @param {string} parentID ID of the parent component. * @param {number} fromIndex Source

* Enqueues removing an element at an index. * * @param {string} parentID ID of the parent component. * @param {number} fromIndex Index of the eleme

* Enqueues setting the text content. * * @param {string} parentID ID of the parent component. * @param {string} textContent Text content to set. *

* Invokes `cb(event, listener, id)`. Avoids using call if no scope is * provided. The `(listener,id)` pair effectively forms the "dispatch" but are

* Converts to a two-complement value from a value where the sign bit is * is placed in the least significant bit. For example, as decimals: *

* Find a node by ID. Optionally search a sub-tree outside of the document * * Use ge if you're not sure whether or not the element exists. You can

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

* Gets the target node from a native browser event by accounting for * inconsistencies in browser DOM APIs. * * @param {object} nativeEvent Native

* Gets the nearest common ancestor ID of two IDs. * * Using this ID scheme, the nearest common ancestor ID is the longest common * prefix of the tw

* Creates a DOM ID prefix to use when mounting React components. * * @param {number} index A unique integer * @return {string} React root ID. * @i

* 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

* NOTE: if you are a previous user of this function, it has been considered * unsafe because it's inconsistent across browsers for some inputs. * In

* Hyphenates a camelcased string, for example: * * > hyphenate('backgroundColor') * < "background-color" * * @param {string} string * @retur

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

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

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

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

* Create the normalize() function passed to a loader plugin's * normalize method.

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

* For each key/value pair, invokes callback func and constructs a resulting * object which contains, for every key in obj, values that are the result

* Behaves the same as `objMap` but invokes func with the key first, and value * second. Use `objMap` unless you need this special case. * Invokes fu