couchdb-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From benk...@apache.org
Subject [5/6] fauxton commit: updated refs/heads/master to e6450a0
Date Mon, 01 Feb 2016 17:40:24 GMT
http://git-wip-us.apache.org/repos/asf/couchdb-fauxton/blob/d0cb3d81/assets/js/libs/react.js
----------------------------------------------------------------------
diff --git a/assets/js/libs/react.js b/assets/js/libs/react.js
index c1578b7..eb71587 100644
--- a/assets/js/libs/react.js
+++ b/assets/js/libs/react.js
@@ -1,8862 +1,7992 @@
 /**
- * React (with addons) v0.13.3
+ * React (with addons) v0.14.6
  */
 (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.React = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
-/**
- * Copyright 2013-2015, 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.
- *
- * @providesModule ReactWithAddons
- */
+  /**
+   * Copyright 2013-2015, 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.
+   *
+   * @providesModule ReactWithAddons
+   */
 
-/**
- * This module exists purely in the open source project, and is meant as a way
- * to create a separate standalone build of React. This build has "addons", or
- * functionality we've built and think might be useful but doesn't have a good
- * place to live inside React core.
- */
+  /**
+   * This module exists purely in the open source project, and is meant as a way
+   * to create a separate standalone build of React. This build has "addons", or
+   * functionality we've built and think might be useful but doesn't have a good
+   * place to live inside React core.
+   */
 
-'use strict';
-
-var LinkedStateMixin = _dereq_(25);
-var React = _dereq_(31);
-var ReactComponentWithPureRenderMixin =
-  _dereq_(42);
-var ReactCSSTransitionGroup = _dereq_(34);
-var ReactFragment = _dereq_(69);
-var ReactTransitionGroup = _dereq_(98);
-var ReactUpdates = _dereq_(100);
-
-var cx = _dereq_(127);
-var cloneWithProps = _dereq_(122);
-var update = _dereq_(170);
-
-React.addons = {
-  CSSTransitionGroup: ReactCSSTransitionGroup,
-  LinkedStateMixin: LinkedStateMixin,
-  PureRenderMixin: ReactComponentWithPureRenderMixin,
-  TransitionGroup: ReactTransitionGroup,
-
-  batchedUpdates: ReactUpdates.batchedUpdates,
-  classSet: cx,
-  cloneWithProps: cloneWithProps,
-  createFragment: ReactFragment.create,
-  update: update
-};
-
-if ("production" !== "development") {
-  React.addons.Perf = _dereq_(61);
-  React.addons.TestUtils = _dereq_(95);
-}
-
-module.exports = React;
-
-},{"100":100,"122":122,"127":127,"170":170,"25":25,"31":31,"34":34,"42":42,"61":61,"69":69,"95":95,"98":98}],2:[function(_dereq_,module,exports){
-/**
- * Copyright 2013-2015, 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.
- *
- * @providesModule AutoFocusMixin
- * @typechecks static-only
- */
+  'use strict';
+
+  var LinkedStateMixin = _dereq_(22);
+  var React = _dereq_(26);
+  var ReactComponentWithPureRenderMixin = _dereq_(37);
+  var ReactCSSTransitionGroup = _dereq_(29);
+  var ReactFragment = _dereq_(64);
+  var ReactTransitionGroup = _dereq_(94);
+  var ReactUpdates = _dereq_(96);
+
+  var cloneWithProps = _dereq_(118);
+  var shallowCompare = _dereq_(140);
+  var update = _dereq_(143);
+  var warning = _dereq_(173);
+
+  var warnedAboutBatchedUpdates = false;
+
+  React.addons = {
+    CSSTransitionGroup: ReactCSSTransitionGroup,
+    LinkedStateMixin: LinkedStateMixin,
+    PureRenderMixin: ReactComponentWithPureRenderMixin,
+    TransitionGroup: ReactTransitionGroup,
+
+    batchedUpdates: function () {
+      if ("development" !== 'production') {
+        "development" !== 'production' ? warning(warnedAboutBatchedUpdates, 'React.addons.batchedUpdates is deprecated. Use ' + 'ReactDOM.unstable_batchedUpdates instead.') : undefined;
+        warnedAboutBatchedUpdates = true;
+      }
+      return ReactUpdates.batchedUpdates.apply(this, arguments);
+    },
+    cloneWithProps: cloneWithProps,
+    createFragment: ReactFragment.create,
+    shallowCompare: shallowCompare,
+    update: update
+  };
+
+  if ("development" !== 'production') {
+    React.addons.Perf = _dereq_(55);
+    React.addons.TestUtils = _dereq_(91);
+  }
+
+  module.exports = React;
+},{"118":118,"140":140,"143":143,"173":173,"22":22,"26":26,"29":29,"37":37,"55":55,"64":64,"91":91,"94":94,"96":96}],2:[function(_dereq_,module,exports){
+  /**
+   * Copyright 2013-2015, 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.
+   *
+   * @providesModule AutoFocusUtils
+   * @typechecks static-only
+   */
 
-'use strict';
+  'use strict';
 
-var focusNode = _dereq_(134);
+  var ReactMount = _dereq_(72);
 
-var AutoFocusMixin = {
-  componentDidMount: function() {
-    if (this.props.autoFocus) {
-      focusNode(this.getDOMNode());
+  var findDOMNode = _dereq_(122);
+  var focusNode = _dereq_(155);
+
+  var Mixin = {
+    componentDidMount: function () {
+      if (this.props.autoFocus) {
+        focusNode(findDOMNode(this));
+      }
     }
-  }
-};
+  };
 
-module.exports = AutoFocusMixin;
+  var AutoFocusUtils = {
+    Mixin: Mixin,
 
-},{"134":134}],3:[function(_dereq_,module,exports){
-/**
- * Copyright 2013-2015 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.
- *
- * @providesModule BeforeInputEventPlugin
- * @typechecks static-only
- */
+    focusDOMComponent: function () {
+      focusNode(ReactMount.getNode(this._rootNodeID));
+    }
+  };
+
+  module.exports = AutoFocusUtils;
+},{"122":122,"155":155,"72":72}],3:[function(_dereq_,module,exports){
+  /**
+   * Copyright 2013-2015 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.
+   *
+   * @providesModule BeforeInputEventPlugin
+   * @typechecks static-only
+   */
 
-'use strict';
+  'use strict';
 
-var EventConstants = _dereq_(16);
-var EventPropagators = _dereq_(21);
-var ExecutionEnvironment = _dereq_(22);
-var FallbackCompositionState = _dereq_(23);
-var SyntheticCompositionEvent = _dereq_(106);
-var SyntheticInputEvent = _dereq_(110);
+  var EventConstants = _dereq_(15);
+  var EventPropagators = _dereq_(19);
+  var ExecutionEnvironment = _dereq_(147);
+  var FallbackCompositionState = _dereq_(20);
+  var SyntheticCompositionEvent = _dereq_(103);
+  var SyntheticInputEvent = _dereq_(107);
 
-var keyOf = _dereq_(157);
+  var keyOf = _dereq_(166);
 
-var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
-var START_KEYCODE = 229;
+  var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
+  var START_KEYCODE = 229;
 
-var canUseCompositionEvent = (
-  ExecutionEnvironment.canUseDOM &&
-  'CompositionEvent' in window
-);
+  var canUseCompositionEvent = ExecutionEnvironment.canUseDOM && 'CompositionEvent' in window;
 
-var documentMode = null;
-if (ExecutionEnvironment.canUseDOM && 'documentMode' in document) {
-  documentMode = document.documentMode;
-}
+  var documentMode = null;
+  if (ExecutionEnvironment.canUseDOM && 'documentMode' in document) {
+    documentMode = document.documentMode;
+  }
 
 // Webkit offers a very useful `textInput` event that can be used to
 // directly represent `beforeInput`. The IE `textinput` event is not as
 // useful, so we don't use it.
-var canUseTextInputEvent = (
-  ExecutionEnvironment.canUseDOM &&
-  'TextEvent' in window &&
-  !documentMode &&
-  !isPresto()
-);
+  var canUseTextInputEvent = ExecutionEnvironment.canUseDOM && 'TextEvent' in window && !documentMode && !isPresto();
 
 // In IE9+, we have access to composition events, but the data supplied
 // by the native compositionend event may be incorrect. Japanese ideographic
 // spaces, for instance (\u3000) are not recorded correctly.
-var useFallbackCompositionData = (
-  ExecutionEnvironment.canUseDOM &&
-  (
-    (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11)
-  )
-);
+  var useFallbackCompositionData = ExecutionEnvironment.canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11);
 
-/**
- * Opera <= 12 includes TextEvent in window, but does not fire
- * text input events. Rely on keypress instead.
- */
-function isPresto() {
-  var opera = window.opera;
-  return (
-    typeof opera === 'object' &&
-    typeof opera.version === 'function' &&
-    parseInt(opera.version(), 10) <= 12
-  );
-}
+  /**
+   * Opera <= 12 includes TextEvent in window, but does not fire
+   * text input events. Rely on keypress instead.
+   */
+  function isPresto() {
+    var opera = window.opera;
+    return typeof opera === 'object' && typeof opera.version === 'function' && parseInt(opera.version(), 10) <= 12;
+  }
 
-var SPACEBAR_CODE = 32;
-var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
+  var SPACEBAR_CODE = 32;
+  var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
 
-var topLevelTypes = EventConstants.topLevelTypes;
+  var topLevelTypes = EventConstants.topLevelTypes;
 
 // Events and their corresponding property names.
-var eventTypes = {
-  beforeInput: {
-    phasedRegistrationNames: {
-      bubbled: keyOf({onBeforeInput: null}),
-      captured: keyOf({onBeforeInputCapture: null})
-    },
-    dependencies: [
-      topLevelTypes.topCompositionEnd,
-      topLevelTypes.topKeyPress,
-      topLevelTypes.topTextInput,
-      topLevelTypes.topPaste
-    ]
-  },
-  compositionEnd: {
-    phasedRegistrationNames: {
-      bubbled: keyOf({onCompositionEnd: null}),
-      captured: keyOf({onCompositionEndCapture: null})
-    },
-    dependencies: [
-      topLevelTypes.topBlur,
-      topLevelTypes.topCompositionEnd,
-      topLevelTypes.topKeyDown,
-      topLevelTypes.topKeyPress,
-      topLevelTypes.topKeyUp,
-      topLevelTypes.topMouseDown
-    ]
-  },
-  compositionStart: {
-    phasedRegistrationNames: {
-      bubbled: keyOf({onCompositionStart: null}),
-      captured: keyOf({onCompositionStartCapture: null})
-    },
-    dependencies: [
-      topLevelTypes.topBlur,
-      topLevelTypes.topCompositionStart,
-      topLevelTypes.topKeyDown,
-      topLevelTypes.topKeyPress,
-      topLevelTypes.topKeyUp,
-      topLevelTypes.topMouseDown
-    ]
-  },
-  compositionUpdate: {
-    phasedRegistrationNames: {
-      bubbled: keyOf({onCompositionUpdate: null}),
-      captured: keyOf({onCompositionUpdateCapture: null})
-    },
-    dependencies: [
-      topLevelTypes.topBlur,
-      topLevelTypes.topCompositionUpdate,
-      topLevelTypes.topKeyDown,
-      topLevelTypes.topKeyPress,
-      topLevelTypes.topKeyUp,
-      topLevelTypes.topMouseDown
-    ]
-  }
-};
+  var eventTypes = {
+    beforeInput: {
+      phasedRegistrationNames: {
+        bubbled: keyOf({ onBeforeInput: null }),
+        captured: keyOf({ onBeforeInputCapture: null })
+      },
+      dependencies: [topLevelTypes.topCompositionEnd, topLevelTypes.topKeyPress, topLevelTypes.topTextInput, topLevelTypes.topPaste]
+    },
+    compositionEnd: {
+      phasedRegistrationNames: {
+        bubbled: keyOf({ onCompositionEnd: null }),
+        captured: keyOf({ onCompositionEndCapture: null })
+      },
+      dependencies: [topLevelTypes.topBlur, topLevelTypes.topCompositionEnd, topLevelTypes.topKeyDown, topLevelTypes.topKeyPress, topLevelTypes.topKeyUp, topLevelTypes.topMouseDown]
+    },
+    compositionStart: {
+      phasedRegistrationNames: {
+        bubbled: keyOf({ onCompositionStart: null }),
+        captured: keyOf({ onCompositionStartCapture: null })
+      },
+      dependencies: [topLevelTypes.topBlur, topLevelTypes.topCompositionStart, topLevelTypes.topKeyDown, topLevelTypes.topKeyPress, topLevelTypes.topKeyUp, topLevelTypes.topMouseDown]
+    },
+    compositionUpdate: {
+      phasedRegistrationNames: {
+        bubbled: keyOf({ onCompositionUpdate: null }),
+        captured: keyOf({ onCompositionUpdateCapture: null })
+      },
+      dependencies: [topLevelTypes.topBlur, topLevelTypes.topCompositionUpdate, topLevelTypes.topKeyDown, topLevelTypes.topKeyPress, topLevelTypes.topKeyUp, topLevelTypes.topMouseDown]
+    }
+  };
 
 // Track whether we've ever handled a keypress on the space key.
-var hasSpaceKeypress = false;
+  var hasSpaceKeypress = false;
 
-/**
- * Return whether a native keypress event is assumed to be a command.
- * This is required because Firefox fires `keypress` events for key commands
- * (cut, copy, select-all, etc.) even though no character is inserted.
- */
-function isKeypressCommand(nativeEvent) {
-  return (
-    (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) &&
-    // ctrlKey && altKey is equivalent to AltGr, and is not a command.
-    !(nativeEvent.ctrlKey && nativeEvent.altKey)
-  );
-}
-
-
-/**
- * Translate native top level events into event types.
- *
- * @param {string} topLevelType
- * @return {object}
- */
-function getCompositionEventType(topLevelType) {
-  switch (topLevelType) {
-    case topLevelTypes.topCompositionStart:
-      return eventTypes.compositionStart;
-    case topLevelTypes.topCompositionEnd:
-      return eventTypes.compositionEnd;
-    case topLevelTypes.topCompositionUpdate:
-      return eventTypes.compositionUpdate;
+  /**
+   * Return whether a native keypress event is assumed to be a command.
+   * This is required because Firefox fires `keypress` events for key commands
+   * (cut, copy, select-all, etc.) even though no character is inserted.
+   */
+  function isKeypressCommand(nativeEvent) {
+    return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) &&
+        // ctrlKey && altKey is equivalent to AltGr, and is not a command.
+      !(nativeEvent.ctrlKey && nativeEvent.altKey);
   }
-}
-
-/**
- * Does our fallback best-guess model think this event signifies that
- * composition has begun?
- *
- * @param {string} topLevelType
- * @param {object} nativeEvent
- * @return {boolean}
- */
-function isFallbackCompositionStart(topLevelType, nativeEvent) {
-  return (
-    topLevelType === topLevelTypes.topKeyDown &&
-    nativeEvent.keyCode === START_KEYCODE
-  );
-}
 
-/**
- * Does our fallback mode think that this event is the end of composition?
- *
- * @param {string} topLevelType
- * @param {object} nativeEvent
- * @return {boolean}
- */
-function isFallbackCompositionEnd(topLevelType, nativeEvent) {
-  switch (topLevelType) {
-    case topLevelTypes.topKeyUp:
-      // Command keys insert or clear IME input.
-      return (END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1);
-    case topLevelTypes.topKeyDown:
-      // Expect IME keyCode on each keydown. If we get any other
-      // code we must have exited earlier.
-      return (nativeEvent.keyCode !== START_KEYCODE);
-    case topLevelTypes.topKeyPress:
-    case topLevelTypes.topMouseDown:
-    case topLevelTypes.topBlur:
-      // Events are not possible without cancelling IME.
-      return true;
-    default:
-      return false;
+  /**
+   * Translate native top level events into event types.
+   *
+   * @param {string} topLevelType
+   * @return {object}
+   */
+  function getCompositionEventType(topLevelType) {
+    switch (topLevelType) {
+      case topLevelTypes.topCompositionStart:
+        return eventTypes.compositionStart;
+      case topLevelTypes.topCompositionEnd:
+        return eventTypes.compositionEnd;
+      case topLevelTypes.topCompositionUpdate:
+        return eventTypes.compositionUpdate;
+    }
   }
-}
 
-/**
- * Google Input Tools provides composition data via a CustomEvent,
- * with the `data` property populated in the `detail` object. If this
- * is available on the event object, use it. If not, this is a plain
- * composition event and we have nothing special to extract.
- *
- * @param {object} nativeEvent
- * @return {?string}
- */
-function getDataFromCustomEvent(nativeEvent) {
-  var detail = nativeEvent.detail;
-  if (typeof detail === 'object' && 'data' in detail) {
-    return detail.data;
+  /**
+   * Does our fallback best-guess model think this event signifies that
+   * composition has begun?
+   *
+   * @param {string} topLevelType
+   * @param {object} nativeEvent
+   * @return {boolean}
+   */
+  function isFallbackCompositionStart(topLevelType, nativeEvent) {
+    return topLevelType === topLevelTypes.topKeyDown && nativeEvent.keyCode === START_KEYCODE;
   }
-  return null;
-}
 
-// Track the current IME composition fallback object, if any.
-var currentComposition = null;
+  /**
+   * Does our fallback mode think that this event is the end of composition?
+   *
+   * @param {string} topLevelType
+   * @param {object} nativeEvent
+   * @return {boolean}
+   */
+  function isFallbackCompositionEnd(topLevelType, nativeEvent) {
+    switch (topLevelType) {
+      case topLevelTypes.topKeyUp:
+        // Command keys insert or clear IME input.
+        return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
+      case topLevelTypes.topKeyDown:
+        // Expect IME keyCode on each keydown. If we get any other
+        // code we must have exited earlier.
+        return nativeEvent.keyCode !== START_KEYCODE;
+      case topLevelTypes.topKeyPress:
+      case topLevelTypes.topMouseDown:
+      case topLevelTypes.topBlur:
+        // Events are not possible without cancelling IME.
+        return true;
+      default:
+        return false;
+    }
+  }
 
-/**
- * @param {string} topLevelType Record from `EventConstants`.
- * @param {DOMEventTarget} topLevelTarget The listening component root node.
- * @param {string} topLevelTargetID ID of `topLevelTarget`.
- * @param {object} nativeEvent Native browser event.
- * @return {?object} A SyntheticCompositionEvent.
- */
-function extractCompositionEvent(
-  topLevelType,
-  topLevelTarget,
-  topLevelTargetID,
-  nativeEvent
-) {
-  var eventType;
-  var fallbackData;
-
-  if (canUseCompositionEvent) {
-    eventType = getCompositionEventType(topLevelType);
-  } else if (!currentComposition) {
-    if (isFallbackCompositionStart(topLevelType, nativeEvent)) {
-      eventType = eventTypes.compositionStart;
-    }
-  } else if (isFallbackCompositionEnd(topLevelType, nativeEvent)) {
-    eventType = eventTypes.compositionEnd;
-  }
-
-  if (!eventType) {
+  /**
+   * Google Input Tools provides composition data via a CustomEvent,
+   * with the `data` property populated in the `detail` object. If this
+   * is available on the event object, use it. If not, this is a plain
+   * composition event and we have nothing special to extract.
+   *
+   * @param {object} nativeEvent
+   * @return {?string}
+   */
+  function getDataFromCustomEvent(nativeEvent) {
+    var detail = nativeEvent.detail;
+    if (typeof detail === 'object' && 'data' in detail) {
+      return detail.data;
+    }
     return null;
   }
 
-  if (useFallbackCompositionData) {
-    // The current composition is stored statically and must not be
-    // overwritten while composition continues.
-    if (!currentComposition && eventType === eventTypes.compositionStart) {
-      currentComposition = FallbackCompositionState.getPooled(topLevelTarget);
-    } else if (eventType === eventTypes.compositionEnd) {
-      if (currentComposition) {
-        fallbackData = currentComposition.getData();
+// Track the current IME composition fallback object, if any.
+  var currentComposition = null;
+
+  /**
+   * @param {string} topLevelType Record from `EventConstants`.
+   * @param {DOMEventTarget} topLevelTarget The listening component root node.
+   * @param {string} topLevelTargetID ID of `topLevelTarget`.
+   * @param {object} nativeEvent Native browser event.
+   * @return {?object} A SyntheticCompositionEvent.
+   */
+  function extractCompositionEvent(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) {
+    var eventType;
+    var fallbackData;
+
+    if (canUseCompositionEvent) {
+      eventType = getCompositionEventType(topLevelType);
+    } else if (!currentComposition) {
+      if (isFallbackCompositionStart(topLevelType, nativeEvent)) {
+        eventType = eventTypes.compositionStart;
       }
+    } else if (isFallbackCompositionEnd(topLevelType, nativeEvent)) {
+      eventType = eventTypes.compositionEnd;
     }
-  }
 
-  var event = SyntheticCompositionEvent.getPooled(
-    eventType,
-    topLevelTargetID,
-    nativeEvent
-  );
+    if (!eventType) {
+      return null;
+    }
 
-  if (fallbackData) {
-    // Inject data generated from fallback path into the synthetic event.
-    // This matches the property of native CompositionEventInterface.
-    event.data = fallbackData;
-  } else {
-    var customData = getDataFromCustomEvent(nativeEvent);
-    if (customData !== null) {
-      event.data = customData;
+    if (useFallbackCompositionData) {
+      // The current composition is stored statically and must not be
+      // overwritten while composition continues.
+      if (!currentComposition && eventType === eventTypes.compositionStart) {
+        currentComposition = FallbackCompositionState.getPooled(topLevelTarget);
+      } else if (eventType === eventTypes.compositionEnd) {
+        if (currentComposition) {
+          fallbackData = currentComposition.getData();
+        }
+      }
     }
-  }
 
-  EventPropagators.accumulateTwoPhaseDispatches(event);
-  return event;
-}
+    var event = SyntheticCompositionEvent.getPooled(eventType, topLevelTargetID, nativeEvent, nativeEventTarget);
 
-/**
- * @param {string} topLevelType Record from `EventConstants`.
- * @param {object} nativeEvent Native browser event.
- * @return {?string} The string corresponding to this `beforeInput` event.
- */
-function getNativeBeforeInputChars(topLevelType, nativeEvent) {
-  switch (topLevelType) {
-    case topLevelTypes.topCompositionEnd:
-      return getDataFromCustomEvent(nativeEvent);
-    case topLevelTypes.topKeyPress:
-      /**
-       * If native `textInput` events are available, our goal is to make
-       * use of them. However, there is a special case: the spacebar key.
-       * In Webkit, preventing default on a spacebar `textInput` event
-       * cancels character insertion, but it *also* causes the browser
-       * to fall back to its default spacebar behavior of scrolling the
-       * page.
-       *
-       * Tracking at:
-       * https://code.google.com/p/chromium/issues/detail?id=355103
-       *
-       * To avoid this issue, use the keypress event as if no `textInput`
-       * event is available.
-       */
-      var which = nativeEvent.which;
-      if (which !== SPACEBAR_CODE) {
-        return null;
+    if (fallbackData) {
+      // Inject data generated from fallback path into the synthetic event.
+      // This matches the property of native CompositionEventInterface.
+      event.data = fallbackData;
+    } else {
+      var customData = getDataFromCustomEvent(nativeEvent);
+      if (customData !== null) {
+        event.data = customData;
       }
+    }
 
-      hasSpaceKeypress = true;
-      return SPACEBAR_CHAR;
+    EventPropagators.accumulateTwoPhaseDispatches(event);
+    return event;
+  }
 
-    case topLevelTypes.topTextInput:
-      // Record the characters to be added to the DOM.
-      var chars = nativeEvent.data;
+  /**
+   * @param {string} topLevelType Record from `EventConstants`.
+   * @param {object} nativeEvent Native browser event.
+   * @return {?string} The string corresponding to this `beforeInput` event.
+   */
+  function getNativeBeforeInputChars(topLevelType, nativeEvent) {
+    switch (topLevelType) {
+      case topLevelTypes.topCompositionEnd:
+        return getDataFromCustomEvent(nativeEvent);
+      case topLevelTypes.topKeyPress:
+        /**
+         * If native `textInput` events are available, our goal is to make
+         * use of them. However, there is a special case: the spacebar key.
+         * In Webkit, preventing default on a spacebar `textInput` event
+         * cancels character insertion, but it *also* causes the browser
+         * to fall back to its default spacebar behavior of scrolling the
+         * page.
+         *
+         * Tracking at:
+         * https://code.google.com/p/chromium/issues/detail?id=355103
+         *
+         * To avoid this issue, use the keypress event as if no `textInput`
+         * event is available.
+         */
+        var which = nativeEvent.which;
+        if (which !== SPACEBAR_CODE) {
+          return null;
+        }
 
-      // If it's a spacebar character, assume that we have already handled
-      // it at the keypress level and bail immediately. Android Chrome
-      // doesn't give us keycodes, so we need to blacklist it.
-      if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
-        return null;
-      }
+        hasSpaceKeypress = true;
+        return SPACEBAR_CHAR;
 
-      return chars;
+      case topLevelTypes.topTextInput:
+        // Record the characters to be added to the DOM.
+        var chars = nativeEvent.data;
 
-    default:
-      // For other native event types, do nothing.
-      return null;
-  }
-}
+        // If it's a spacebar character, assume that we have already handled
+        // it at the keypress level and bail immediately. Android Chrome
+        // doesn't give us keycodes, so we need to blacklist it.
+        if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
+          return null;
+        }
 
-/**
- * For browsers that do not provide the `textInput` event, extract the
- * appropriate string to use for SyntheticInputEvent.
- *
- * @param {string} topLevelType Record from `EventConstants`.
- * @param {object} nativeEvent Native browser event.
- * @return {?string} The fallback string for this `beforeInput` event.
- */
-function getFallbackBeforeInputChars(topLevelType, nativeEvent) {
-  // If we are currently composing (IME) and using a fallback to do so,
-  // try to extract the composed characters from the fallback object.
-  if (currentComposition) {
-    if (
-      topLevelType === topLevelTypes.topCompositionEnd ||
-      isFallbackCompositionEnd(topLevelType, nativeEvent)
-    ) {
-      var chars = currentComposition.getData();
-      FallbackCompositionState.release(currentComposition);
-      currentComposition = null;
-      return chars;
+        return chars;
+
+      default:
+        // For other native event types, do nothing.
+        return null;
     }
-    return null;
   }
 
-  switch (topLevelType) {
-    case topLevelTypes.topPaste:
-      // If a paste event occurs after a keypress, throw out the input
-      // chars. Paste events should not lead to BeforeInput events.
-      return null;
-    case topLevelTypes.topKeyPress:
-      /**
-       * As of v27, Firefox may fire keypress events even when no character
-       * will be inserted. A few possibilities:
-       *
-       * - `which` is `0`. Arrow keys, Esc key, etc.
-       *
-       * - `which` is the pressed key code, but no char is available.
-       *   Ex: 'AltGr + d` in Polish. There is no modified character for
-       *   this key combination and no character is inserted into the
-       *   document, but FF fires the keypress for char code `100` anyway.
-       *   No `input` event will occur.
-       *
-       * - `which` is the pressed key code, but a command combination is
-       *   being used. Ex: `Cmd+C`. No character is inserted, and no
-       *   `input` event will occur.
-       */
-      if (nativeEvent.which && !isKeypressCommand(nativeEvent)) {
-        return String.fromCharCode(nativeEvent.which);
+  /**
+   * For browsers that do not provide the `textInput` event, extract the
+   * appropriate string to use for SyntheticInputEvent.
+   *
+   * @param {string} topLevelType Record from `EventConstants`.
+   * @param {object} nativeEvent Native browser event.
+   * @return {?string} The fallback string for this `beforeInput` event.
+   */
+  function getFallbackBeforeInputChars(topLevelType, nativeEvent) {
+    // If we are currently composing (IME) and using a fallback to do so,
+    // try to extract the composed characters from the fallback object.
+    if (currentComposition) {
+      if (topLevelType === topLevelTypes.topCompositionEnd || isFallbackCompositionEnd(topLevelType, nativeEvent)) {
+        var chars = currentComposition.getData();
+        FallbackCompositionState.release(currentComposition);
+        currentComposition = null;
+        return chars;
       }
       return null;
-    case topLevelTypes.topCompositionEnd:
-      return useFallbackCompositionData ? null : nativeEvent.data;
-    default:
-      return null;
-  }
-}
-
-/**
- * Extract a SyntheticInputEvent for `beforeInput`, based on either native
- * `textInput` or fallback behavior.
- *
- * @param {string} topLevelType Record from `EventConstants`.
- * @param {DOMEventTarget} topLevelTarget The listening component root node.
- * @param {string} topLevelTargetID ID of `topLevelTarget`.
- * @param {object} nativeEvent Native browser event.
- * @return {?object} A SyntheticInputEvent.
- */
-function extractBeforeInputEvent(
-  topLevelType,
-  topLevelTarget,
-  topLevelTargetID,
-  nativeEvent
-) {
-  var chars;
-
-  if (canUseTextInputEvent) {
-    chars = getNativeBeforeInputChars(topLevelType, nativeEvent);
-  } else {
-    chars = getFallbackBeforeInputChars(topLevelType, nativeEvent);
-  }
+    }
 
-  // If no characters are being inserted, no BeforeInput event should
-  // be fired.
-  if (!chars) {
-    return null;
+    switch (topLevelType) {
+      case topLevelTypes.topPaste:
+        // If a paste event occurs after a keypress, throw out the input
+        // chars. Paste events should not lead to BeforeInput events.
+        return null;
+      case topLevelTypes.topKeyPress:
+        /**
+         * As of v27, Firefox may fire keypress events even when no character
+         * will be inserted. A few possibilities:
+         *
+         * - `which` is `0`. Arrow keys, Esc key, etc.
+         *
+         * - `which` is the pressed key code, but no char is available.
+         *   Ex: 'AltGr + d` in Polish. There is no modified character for
+         *   this key combination and no character is inserted into the
+         *   document, but FF fires the keypress for char code `100` anyway.
+         *   No `input` event will occur.
+         *
+         * - `which` is the pressed key code, but a command combination is
+         *   being used. Ex: `Cmd+C`. No character is inserted, and no
+         *   `input` event will occur.
+         */
+        if (nativeEvent.which && !isKeypressCommand(nativeEvent)) {
+          return String.fromCharCode(nativeEvent.which);
+        }
+        return null;
+      case topLevelTypes.topCompositionEnd:
+        return useFallbackCompositionData ? null : nativeEvent.data;
+      default:
+        return null;
+    }
   }
 
-  var event = SyntheticInputEvent.getPooled(
-    eventTypes.beforeInput,
-    topLevelTargetID,
-    nativeEvent
-  );
-
-  event.data = chars;
-  EventPropagators.accumulateTwoPhaseDispatches(event);
-  return event;
-}
-
-/**
- * Create an `onBeforeInput` event to match
- * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
- *
- * This event plugin is based on the native `textInput` event
- * available in Chrome, Safari, Opera, and IE. This event fires after
- * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
- *
- * `beforeInput` is spec'd but not implemented in any browsers, and
- * the `input` event does not provide any useful information about what has
- * actually been added, contrary to the spec. Thus, `textInput` is the best
- * available event to identify the characters that have actually been inserted
- * into the target node.
- *
- * This plugin is also responsible for emitting `composition` events, thus
- * allowing us to share composition fallback code for both `beforeInput` and
- * `composition` event types.
- */
-var BeforeInputEventPlugin = {
-
-  eventTypes: eventTypes,
-
   /**
+   * Extract a SyntheticInputEvent for `beforeInput`, based on either native
+   * `textInput` or fallback behavior.
+   *
    * @param {string} topLevelType Record from `EventConstants`.
    * @param {DOMEventTarget} topLevelTarget The listening component root node.
    * @param {string} topLevelTargetID ID of `topLevelTarget`.
    * @param {object} nativeEvent Native browser event.
-   * @return {*} An accumulation of synthetic events.
-   * @see {EventPluginHub.extractEvents}
-   */
-  extractEvents: function(
-    topLevelType,
-    topLevelTarget,
-    topLevelTargetID,
-    nativeEvent
-  ) {
-    return [
-      extractCompositionEvent(
-        topLevelType,
-        topLevelTarget,
-        topLevelTargetID,
-        nativeEvent
-      ),
-      extractBeforeInputEvent(
-        topLevelType,
-        topLevelTarget,
-        topLevelTargetID,
-        nativeEvent
-      )
-    ];
-  }
-};
-
-module.exports = BeforeInputEventPlugin;
-
-},{"106":106,"110":110,"157":157,"16":16,"21":21,"22":22,"23":23}],4:[function(_dereq_,module,exports){
-/**
- * Copyright 2013-2015, 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.
- *
- * @providesModule CSSCore
- * @typechecks
- */
+   * @return {?object} A SyntheticInputEvent.
+   */
+  function extractBeforeInputEvent(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) {
+    var chars;
 
-var invariant = _dereq_(150);
+    if (canUseTextInputEvent) {
+      chars = getNativeBeforeInputChars(topLevelType, nativeEvent);
+    } else {
+      chars = getFallbackBeforeInputChars(topLevelType, nativeEvent);
+    }
 
-/**
- * The CSSCore module specifies the API (and implements most of the methods)
- * that should be used when dealing with the display of elements (via their
- * CSS classes and visibility on screen. It is an API focused on mutating the
- * display and not reading it as no logical state should be encoded in the
- * display of elements.
- */
+    // If no characters are being inserted, no BeforeInput event should
+    // be fired.
+    if (!chars) {
+      return null;
+    }
+
+    var event = SyntheticInputEvent.getPooled(eventTypes.beforeInput, topLevelTargetID, nativeEvent, nativeEventTarget);
 
-var CSSCore = {
+    event.data = chars;
+    EventPropagators.accumulateTwoPhaseDispatches(event);
+    return event;
+  }
 
   /**
-   * Adds the class passed in to the element if it doesn't already have it.
+   * Create an `onBeforeInput` event to match
+   * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
+   *
+   * This event plugin is based on the native `textInput` event
+   * available in Chrome, Safari, Opera, and IE. This event fires after
+   * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
    *
-   * @param {DOMElement} element the element to set the class on
-   * @param {string} className the CSS className
-   * @return {DOMElement} the element passed in
+   * `beforeInput` is spec'd but not implemented in any browsers, and
+   * the `input` event does not provide any useful information about what has
+   * actually been added, contrary to the spec. Thus, `textInput` is the best
+   * available event to identify the characters that have actually been inserted
+   * into the target node.
+   *
+   * This plugin is also responsible for emitting `composition` events, thus
+   * allowing us to share composition fallback code for both `beforeInput` and
+   * `composition` event types.
    */
-  addClass: function(element, className) {
-    ("production" !== "development" ? invariant(
-      !/\s/.test(className),
-      'CSSCore.addClass takes only a single class name. "%s" contains ' +
-      'multiple classes.', className
-    ) : invariant(!/\s/.test(className)));
+  var BeforeInputEventPlugin = {
 
-    if (className) {
-      if (element.classList) {
-        element.classList.add(className);
-      } else if (!CSSCore.hasClass(element, className)) {
-        element.className = element.className + ' ' + className;
-      }
+    eventTypes: eventTypes,
+
+    /**
+     * @param {string} topLevelType Record from `EventConstants`.
+     * @param {DOMEventTarget} topLevelTarget The listening component root node.
+     * @param {string} topLevelTargetID ID of `topLevelTarget`.
+     * @param {object} nativeEvent Native browser event.
+     * @return {*} An accumulation of synthetic events.
+     * @see {EventPluginHub.extractEvents}
+     */
+    extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) {
+      return [extractCompositionEvent(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget), extractBeforeInputEvent(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget)];
     }
-    return element;
-  },
+  };
 
+  module.exports = BeforeInputEventPlugin;
+},{"103":103,"107":107,"147":147,"15":15,"166":166,"19":19,"20":20}],4:[function(_dereq_,module,exports){
   /**
-   * Removes the class passed in from the element
+   * Copyright 2013-2015, Facebook, Inc.
+   * All rights reserved.
    *
-   * @param {DOMElement} element the element to set the class on
-   * @param {string} className the CSS className
-   * @return {DOMElement} the element passed in
+   * 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.
+   *
+   * @providesModule CSSProperty
    */
-  removeClass: function(element, className) {
-    ("production" !== "development" ? invariant(
-      !/\s/.test(className),
-      'CSSCore.removeClass takes only a single class name. "%s" contains ' +
-      'multiple classes.', className
-    ) : invariant(!/\s/.test(className)));
 
-    if (className) {
-      if (element.classList) {
-        element.classList.remove(className);
-      } else if (CSSCore.hasClass(element, className)) {
-        element.className = element.className
-          .replace(new RegExp('(^|\\s)' + className + '(?:\\s|$)', 'g'), '$1')
-          .replace(/\s+/g, ' ') // multiple spaces to one
-          .replace(/^\s*|\s*$/g, ''); // trim the ends
-      }
-    }
-    return element;
-  },
+  'use strict';
 
   /**
-   * Helper to add or remove a class from an element based on a condition.
-   *
-   * @param {DOMElement} element the element to set the class on
-   * @param {string} className the CSS className
-   * @param {*} bool condition to whether to add or remove the class
-   * @return {DOMElement} the element passed in
+   * CSS properties which accept numbers but are not in units of "px".
    */
-  conditionClass: function(element, className, bool) {
-    return (bool ? CSSCore.addClass : CSSCore.removeClass)(element, className);
-  },
+  var isUnitlessNumber = {
+    animationIterationCount: true,
+    boxFlex: true,
+    boxFlexGroup: true,
+    boxOrdinalGroup: true,
+    columnCount: true,
+    flex: true,
+    flexGrow: true,
+    flexPositive: true,
+    flexShrink: true,
+    flexNegative: true,
+    flexOrder: true,
+    fontWeight: true,
+    lineClamp: true,
+    lineHeight: true,
+    opacity: true,
+    order: true,
+    orphans: true,
+    tabSize: true,
+    widows: true,
+    zIndex: true,
+    zoom: true,
+
+    // SVG-related properties
+    fillOpacity: true,
+    stopOpacity: true,
+    strokeDashoffset: true,
+    strokeOpacity: true,
+    strokeWidth: true
+  };
 
   /**
-   * Tests whether the element has the class specified.
-   *
-   * @param {DOMNode|DOMWindow} element the element to set the class on
-   * @param {string} className the CSS className
-   * @return {boolean} true if the element has the class, false if not
+   * @param {string} prefix vendor-specific prefix, eg: Webkit
+   * @param {string} key style name, eg: transitionDuration
+   * @return {string} style name prefixed with `prefix`, properly camelCased, eg:
+   * WebkitTransitionDuration
    */
-  hasClass: function(element, className) {
-    ("production" !== "development" ? invariant(
-      !/\s/.test(className),
-      'CSS.hasClass takes only a single class name.'
-    ) : invariant(!/\s/.test(className)));
-    if (element.classList) {
-      return !!className && element.classList.contains(className);
-    }
-    return (' ' + element.className + ' ').indexOf(' ' + className + ' ') > -1;
+  function prefixKey(prefix, key) {
+    return prefix + key.charAt(0).toUpperCase() + key.substring(1);
   }
 
-};
-
-module.exports = CSSCore;
-
-},{"150":150}],5:[function(_dereq_,module,exports){
-/**
- * Copyright 2013-2015, 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.
- *
- * @providesModule CSSProperty
- */
-
-'use strict';
-
-/**
- * CSS properties which accept numbers but are not in units of "px".
- */
-var isUnitlessNumber = {
-  boxFlex: true,
-  boxFlexGroup: true,
-  columnCount: true,
-  flex: true,
-  flexGrow: true,
-  flexPositive: true,
-  flexShrink: true,
-  flexNegative: true,
-  fontWeight: true,
-  lineClamp: true,
-  lineHeight: true,
-  opacity: true,
-  order: true,
-  orphans: true,
-  widows: true,
-  zIndex: true,
-  zoom: true,
-
-  // SVG-related properties
-  fillOpacity: true,
-  strokeDashoffset: true,
-  strokeOpacity: true,
-  strokeWidth: true
-};
-
-/**
- * @param {string} prefix vendor-specific prefix, eg: Webkit
- * @param {string} key style name, eg: transitionDuration
- * @return {string} style name prefixed with `prefix`, properly camelCased, eg:
- * WebkitTransitionDuration
- */
-function prefixKey(prefix, key) {
-  return prefix + key.charAt(0).toUpperCase() + key.substring(1);
-}
-
-/**
- * Support style names that may come passed in prefixed by adding permutations
- * of vendor prefixes.
- */
-var prefixes = ['Webkit', 'ms', 'Moz', 'O'];
+  /**
+   * Support style names that may come passed in prefixed by adding permutations
+   * of vendor prefixes.
+   */
+  var prefixes = ['Webkit', 'ms', 'Moz', 'O'];
 
 // Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an
 // infinite loop, because it iterates over the newly added props too.
-Object.keys(isUnitlessNumber).forEach(function(prop) {
-  prefixes.forEach(function(prefix) {
-    isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];
+  Object.keys(isUnitlessNumber).forEach(function (prop) {
+    prefixes.forEach(function (prefix) {
+      isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];
+    });
   });
-});
-
-/**
- * Most style properties can be unset by doing .style[prop] = '' but IE8
- * doesn't like doing that with shorthand properties so for the properties that
- * IE8 breaks on, which are listed here, we instead unset each of the
- * individual properties. See http://bugs.jquery.com/ticket/12385.
- * The 4-value 'clock' properties like margin, padding, border-width seem to
- * behave without any problems. Curiously, list-style works too without any
- * special prodding.
- */
-var shorthandPropertyExpansions = {
-  background: {
-    backgroundImage: true,
-    backgroundPosition: true,
-    backgroundRepeat: true,
-    backgroundColor: true
-  },
-  border: {
-    borderWidth: true,
-    borderStyle: true,
-    borderColor: true
-  },
-  borderBottom: {
-    borderBottomWidth: true,
-    borderBottomStyle: true,
-    borderBottomColor: true
-  },
-  borderLeft: {
-    borderLeftWidth: true,
-    borderLeftStyle: true,
-    borderLeftColor: true
-  },
-  borderRight: {
-    borderRightWidth: true,
-    borderRightStyle: true,
-    borderRightColor: true
-  },
-  borderTop: {
-    borderTopWidth: true,
-    borderTopStyle: true,
-    borderTopColor: true
-  },
-  font: {
-    fontStyle: true,
-    fontVariant: true,
-    fontWeight: true,
-    fontSize: true,
-    lineHeight: true,
-    fontFamily: true
-  }
-};
-
-var CSSProperty = {
-  isUnitlessNumber: isUnitlessNumber,
-  shorthandPropertyExpansions: shorthandPropertyExpansions
-};
 
-module.exports = CSSProperty;
-
-},{}],6:[function(_dereq_,module,exports){
-/**
- * Copyright 2013-2015, 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.
- *
- * @providesModule CSSPropertyOperations
- * @typechecks static-only
- */
+  /**
+   * Most style properties can be unset by doing .style[prop] = '' but IE8
+   * doesn't like doing that with shorthand properties so for the properties that
+   * IE8 breaks on, which are listed here, we instead unset each of the
+   * individual properties. See http://bugs.jquery.com/ticket/12385.
+   * The 4-value 'clock' properties like margin, padding, border-width seem to
+   * behave without any problems. Curiously, list-style works too without any
+   * special prodding.
+   */
+  var shorthandPropertyExpansions = {
+    background: {
+      backgroundAttachment: true,
+      backgroundColor: true,
+      backgroundImage: true,
+      backgroundPositionX: true,
+      backgroundPositionY: true,
+      backgroundRepeat: true
+    },
+    backgroundPosition: {
+      backgroundPositionX: true,
+      backgroundPositionY: true
+    },
+    border: {
+      borderWidth: true,
+      borderStyle: true,
+      borderColor: true
+    },
+    borderBottom: {
+      borderBottomWidth: true,
+      borderBottomStyle: true,
+      borderBottomColor: true
+    },
+    borderLeft: {
+      borderLeftWidth: true,
+      borderLeftStyle: true,
+      borderLeftColor: true
+    },
+    borderRight: {
+      borderRightWidth: true,
+      borderRightStyle: true,
+      borderRightColor: true
+    },
+    borderTop: {
+      borderTopWidth: true,
+      borderTopStyle: true,
+      borderTopColor: true
+    },
+    font: {
+      fontStyle: true,
+      fontVariant: true,
+      fontWeight: true,
+      fontSize: true,
+      lineHeight: true,
+      fontFamily: true
+    },
+    outline: {
+      outlineWidth: true,
+      outlineStyle: true,
+      outlineColor: true
+    }
+  };
+
+  var CSSProperty = {
+    isUnitlessNumber: isUnitlessNumber,
+    shorthandPropertyExpansions: shorthandPropertyExpansions
+  };
+
+  module.exports = CSSProperty;
+},{}],5:[function(_dereq_,module,exports){
+  /**
+   * Copyright 2013-2015, 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.
+   *
+   * @providesModule CSSPropertyOperations
+   * @typechecks static-only
+   */
 
-'use strict';
+  'use strict';
 
-var CSSProperty = _dereq_(5);
-var ExecutionEnvironment = _dereq_(22);
+  var CSSProperty = _dereq_(4);
+  var ExecutionEnvironment = _dereq_(147);
+  var ReactPerf = _dereq_(78);
 
-var camelizeStyleName = _dereq_(121);
-var dangerousStyleValue = _dereq_(128);
-var hyphenateStyleName = _dereq_(148);
-var memoizeStringOnly = _dereq_(159);
-var warning = _dereq_(171);
+  var camelizeStyleName = _dereq_(149);
+  var dangerousStyleValue = _dereq_(119);
+  var hyphenateStyleName = _dereq_(160);
+  var memoizeStringOnly = _dereq_(168);
+  var warning = _dereq_(173);
 
-var processStyleName = memoizeStringOnly(function(styleName) {
-  return hyphenateStyleName(styleName);
-});
+  var processStyleName = memoizeStringOnly(function (styleName) {
+    return hyphenateStyleName(styleName);
+  });
 
-var styleFloatAccessor = 'cssFloat';
-if (ExecutionEnvironment.canUseDOM) {
-  // IE8 only supports accessing cssFloat (standard) as styleFloat
-  if (document.documentElement.style.cssFloat === undefined) {
-    styleFloatAccessor = 'styleFloat';
+  var hasShorthandPropertyBug = false;
+  var styleFloatAccessor = 'cssFloat';
+  if (ExecutionEnvironment.canUseDOM) {
+    var tempStyle = document.createElement('div').style;
+    try {
+      // IE8 throws "Invalid argument." if resetting shorthand style properties.
+      tempStyle.font = '';
+    } catch (e) {
+      hasShorthandPropertyBug = true;
+    }
+    // IE8 only supports accessing cssFloat (standard) as styleFloat
+    if (document.documentElement.style.cssFloat === undefined) {
+      styleFloatAccessor = 'styleFloat';
+    }
   }
-}
 
-if ("production" !== "development") {
-  // 'msTransform' is correct, but the other prefixes should be capitalized
-  var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
+  if ("development" !== 'production') {
+    // 'msTransform' is correct, but the other prefixes should be capitalized
+    var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
 
-  // style values shouldn't contain a semicolon
-  var badStyleValueWithSemicolonPattern = /;\s*$/;
+    // style values shouldn't contain a semicolon
+    var badStyleValueWithSemicolonPattern = /;\s*$/;
 
-  var warnedStyleNames = {};
-  var warnedStyleValues = {};
+    var warnedStyleNames = {};
+    var warnedStyleValues = {};
 
-  var warnHyphenatedStyleName = function(name) {
-    if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
-      return;
-    }
+    var warnHyphenatedStyleName = function (name) {
+      if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+        return;
+      }
 
-    warnedStyleNames[name] = true;
-    ("production" !== "development" ? warning(
-      false,
-      'Unsupported style property %s. Did you mean %s?',
-      name,
-      camelizeStyleName(name)
-    ) : null);
-  };
+      warnedStyleNames[name] = true;
+      "development" !== 'production' ? warning(false, 'Unsupported style property %s. Did you mean %s?', name, camelizeStyleName(name)) : undefined;
+    };
 
-  var warnBadVendoredStyleName = function(name) {
-    if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
-      return;
-    }
+    var warnBadVendoredStyleName = function (name) {
+      if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+        return;
+      }
 
-    warnedStyleNames[name] = true;
-    ("production" !== "development" ? warning(
-      false,
-      'Unsupported vendor-prefixed style property %s. Did you mean %s?',
-      name,
-      name.charAt(0).toUpperCase() + name.slice(1)
-    ) : null);
-  };
+      warnedStyleNames[name] = true;
+      "development" !== 'production' ? warning(false, 'Unsupported vendor-prefixed style property %s. Did you mean %s?', name, name.charAt(0).toUpperCase() + name.slice(1)) : undefined;
+    };
 
-  var warnStyleValueWithSemicolon = function(name, value) {
-    if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
-      return;
-    }
+    var warnStyleValueWithSemicolon = function (name, value) {
+      if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
+        return;
+      }
 
-    warnedStyleValues[value] = true;
-    ("production" !== "development" ? warning(
-      false,
-      'Style property values shouldn\'t contain a semicolon. ' +
-      'Try "%s: %s" instead.',
-      name,
-      value.replace(badStyleValueWithSemicolonPattern, '')
-    ) : null);
-  };
+      warnedStyleValues[value] = true;
+      "development" !== 'production' ? warning(false, 'Style property values shouldn\'t contain a semicolon. ' + 'Try "%s: %s" instead.', name, value.replace(badStyleValueWithSemicolonPattern, '')) : undefined;
+    };
+
+    /**
+     * @param {string} name
+     * @param {*} value
+     */
+    var warnValidStyle = function (name, value) {
+      if (name.indexOf('-') > -1) {
+        warnHyphenatedStyleName(name);
+      } else if (badVendoredStyleNamePattern.test(name)) {
+        warnBadVendoredStyleName(name);
+      } else if (badStyleValueWithSemicolonPattern.test(value)) {
+        warnStyleValueWithSemicolon(name, value);
+      }
+    };
+  }
 
   /**
-   * @param {string} name
-   * @param {*} value
+   * Operations for dealing with CSS properties.
    */
-  var warnValidStyle = function(name, value) {
-    if (name.indexOf('-') > -1) {
-      warnHyphenatedStyleName(name);
-    } else if (badVendoredStyleNamePattern.test(name)) {
-      warnBadVendoredStyleName(name);
-    } else if (badStyleValueWithSemicolonPattern.test(value)) {
-      warnStyleValueWithSemicolon(name, value);
+  var CSSPropertyOperations = {
+
+    /**
+     * Serializes a mapping of style properties for use as inline styles:
+     *
+     *   > createMarkupForStyles({width: '200px', height: 0})
+     *   "width:200px;height:0;"
+     *
+     * Undefined values are ignored so that declarative programming is easier.
+     * The result should be HTML-escaped before insertion into the DOM.
+     *
+     * @param {object} styles
+     * @return {?string}
+     */
+    createMarkupForStyles: function (styles) {
+      var serialized = '';
+      for (var styleName in styles) {
+        if (!styles.hasOwnProperty(styleName)) {
+          continue;
+        }
+        var styleValue = styles[styleName];
+        if ("development" !== 'production') {
+          warnValidStyle(styleName, styleValue);
+        }
+        if (styleValue != null) {
+          serialized += processStyleName(styleName) + ':';
+          serialized += dangerousStyleValue(styleName, styleValue) + ';';
+        }
+      }
+      return serialized || null;
+    },
+
+    /**
+     * Sets the value for multiple styles on a node.  If a value is specified as
+     * '' (empty string), the corresponding style property will be unset.
+     *
+     * @param {DOMElement} node
+     * @param {object} styles
+     */
+    setValueForStyles: function (node, styles) {
+      var style = node.style;
+      for (var styleName in styles) {
+        if (!styles.hasOwnProperty(styleName)) {
+          continue;
+        }
+        if ("development" !== 'production') {
+          warnValidStyle(styleName, styles[styleName]);
+        }
+        var styleValue = dangerousStyleValue(styleName, styles[styleName]);
+        if (styleName === 'float') {
+          styleName = styleFloatAccessor;
+        }
+        if (styleValue) {
+          style[styleName] = styleValue;
+        } else {
+          var expansion = hasShorthandPropertyBug && CSSProperty.shorthandPropertyExpansions[styleName];
+          if (expansion) {
+            // Shorthand property that IE8 won't like unsetting, so unset each
+            // component to placate it
+            for (var individualStyleName in expansion) {
+              style[individualStyleName] = '';
+            }
+          } else {
+            style[styleName] = '';
+          }
+        }
+      }
     }
+
   };
-}
 
-/**
- * Operations for dealing with CSS properties.
- */
-var CSSPropertyOperations = {
+  ReactPerf.measureMethods(CSSPropertyOperations, 'CSSPropertyOperations', {
+    setValueForStyles: 'setValueForStyles'
+  });
 
+  module.exports = CSSPropertyOperations;
+},{"119":119,"147":147,"149":149,"160":160,"168":168,"173":173,"4":4,"78":78}],6:[function(_dereq_,module,exports){
   /**
-   * Serializes a mapping of style properties for use as inline styles:
+   * Copyright 2013-2015, Facebook, Inc.
+   * All rights reserved.
    *
-   *   > createMarkupForStyles({width: '200px', height: 0})
-   *   "width:200px;height:0;"
+   * 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.
    *
-   * Undefined values are ignored so that declarative programming is easier.
-   * The result should be HTML-escaped before insertion into the DOM.
-   *
-   * @param {object} styles
-   * @return {?string}
+   * @providesModule CallbackQueue
    */
-  createMarkupForStyles: function(styles) {
-    var serialized = '';
-    for (var styleName in styles) {
-      if (!styles.hasOwnProperty(styleName)) {
-        continue;
-      }
-      var styleValue = styles[styleName];
-      if ("production" !== "development") {
-        warnValidStyle(styleName, styleValue);
-      }
-      if (styleValue != null) {
-        serialized += processStyleName(styleName) + ':';
-        serialized += dangerousStyleValue(styleName, styleValue) + ';';
-      }
-    }
-    return serialized || null;
-  },
+
+  'use strict';
+
+  var PooledClass = _dereq_(25);
+
+  var assign = _dereq_(24);
+  var invariant = _dereq_(161);
 
   /**
-   * Sets the value for multiple styles on a node.  If a value is specified as
-   * '' (empty string), the corresponding style property will be unset.
+   * A specialized pseudo-event module to help keep track of components waiting to
+   * be notified when their DOM representations are available for use.
    *
-   * @param {DOMElement} node
-   * @param {object} styles
+   * This implements `PooledClass`, so you should never need to instantiate this.
+   * Instead, use `CallbackQueue.getPooled()`.
+   *
+   * @class ReactMountReady
+   * @implements PooledClass
+   * @internal
    */
-  setValueForStyles: function(node, styles) {
-    var style = node.style;
-    for (var styleName in styles) {
-      if (!styles.hasOwnProperty(styleName)) {
-        continue;
-      }
-      if ("production" !== "development") {
-        warnValidStyle(styleName, styles[styleName]);
-      }
-      var styleValue = dangerousStyleValue(styleName, styles[styleName]);
-      if (styleName === 'float') {
-        styleName = styleFloatAccessor;
-      }
-      if (styleValue) {
-        style[styleName] = styleValue;
-      } else {
-        var expansion = CSSProperty.shorthandPropertyExpansions[styleName];
-        if (expansion) {
-          // Shorthand property that IE8 won't like unsetting, so unset each
-          // component to placate it
-          for (var individualStyleName in expansion) {
-            style[individualStyleName] = '';
-          }
-        } else {
-          style[styleName] = '';
-        }
-      }
-    }
+  function CallbackQueue() {
+    this._callbacks = null;
+    this._contexts = null;
   }
 
-};
-
-module.exports = CSSPropertyOperations;
+  assign(CallbackQueue.prototype, {
 
-},{"121":121,"128":128,"148":148,"159":159,"171":171,"22":22,"5":5}],7:[function(_dereq_,module,exports){
-/**
- * Copyright 2013-2015, 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.
- *
- * @providesModule CallbackQueue
- */
+    /**
+     * Enqueues a callback to be invoked when `notifyAll` is invoked.
+     *
+     * @param {function} callback Invoked when `notifyAll` is invoked.
+     * @param {?object} context Context to call `callback` with.
+     * @internal
+     */
+    enqueue: function (callback, context) {
+      this._callbacks = this._callbacks || [];
+      this._contexts = this._contexts || [];
+      this._callbacks.push(callback);
+      this._contexts.push(context);
+    },
 
-'use strict';
+    /**
+     * Invokes all enqueued callbacks and clears the queue. This is invoked after
+     * the DOM representation of a component has been created or updated.
+     *
+     * @internal
+     */
+    notifyAll: function () {
+      var callbacks = this._callbacks;
+      var contexts = this._contexts;
+      if (callbacks) {
+        !(callbacks.length === contexts.length) ? "development" !== 'production' ? invariant(false, 'Mismatched list of contexts in callback queue') : invariant(false) : undefined;
+        this._callbacks = null;
+        this._contexts = null;
+        for (var i = 0; i < callbacks.length; i++) {
+          callbacks[i].call(contexts[i]);
+        }
+        callbacks.length = 0;
+        contexts.length = 0;
+      }
+    },
 
-var PooledClass = _dereq_(30);
+    /**
+     * Resets the internal queue.
+     *
+     * @internal
+     */
+    reset: function () {
+      this._callbacks = null;
+      this._contexts = null;
+    },
 
-var assign = _dereq_(29);
-var invariant = _dereq_(150);
+    /**
+     * `PooledClass` looks for this.
+     */
+    destructor: function () {
+      this.reset();
+    }
 
-/**
- * A specialized pseudo-event module to help keep track of components waiting to
- * be notified when their DOM representations are available for use.
- *
- * This implements `PooledClass`, so you should never need to instantiate this.
- * Instead, use `CallbackQueue.getPooled()`.
- *
- * @class ReactMountReady
- * @implements PooledClass
- * @internal
- */
-function CallbackQueue() {
-  this._callbacks = null;
-  this._contexts = null;
-}
+  });
 
-assign(CallbackQueue.prototype, {
+  PooledClass.addPoolingTo(CallbackQueue);
 
+  module.exports = CallbackQueue;
+},{"161":161,"24":24,"25":25}],7:[function(_dereq_,module,exports){
   /**
-   * Enqueues a callback to be invoked when `notifyAll` is invoked.
+   * Copyright 2013-2015, Facebook, Inc.
+   * All rights reserved.
    *
-   * @param {function} callback Invoked when `notifyAll` is invoked.
-   * @param {?object} context Context to call `callback` with.
-   * @internal
-   */
-  enqueue: function(callback, context) {
-    this._callbacks = this._callbacks || [];
-    this._contexts = this._contexts || [];
-    this._callbacks.push(callback);
-    this._contexts.push(context);
-  },
-
-  /**
-   * Invokes all enqueued callbacks and clears the queue. This is invoked after
-   * the DOM representation of a component has been created or updated.
+   * 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.
    *
-   * @internal
+   * @providesModule ChangeEventPlugin
    */
-  notifyAll: function() {
-    var callbacks = this._callbacks;
-    var contexts = this._contexts;
-    if (callbacks) {
-      ("production" !== "development" ? invariant(
-        callbacks.length === contexts.length,
-        'Mismatched list of contexts in callback queue'
-      ) : invariant(callbacks.length === contexts.length));
-      this._callbacks = null;
-      this._contexts = null;
-      for (var i = 0, l = callbacks.length; i < l; i++) {
-        callbacks[i].call(contexts[i]);
-      }
-      callbacks.length = 0;
-      contexts.length = 0;
+
+  'use strict';
+
+  var EventConstants = _dereq_(15);
+  var EventPluginHub = _dereq_(16);
+  var EventPropagators = _dereq_(19);
+  var ExecutionEnvironment = _dereq_(147);
+  var ReactUpdates = _dereq_(96);
+  var SyntheticEvent = _dereq_(105);
+
+  var getEventTarget = _dereq_(128);
+  var isEventSupported = _dereq_(133);
+  var isTextInputElement = _dereq_(134);
+  var keyOf = _dereq_(166);
+
+  var topLevelTypes = EventConstants.topLevelTypes;
+
+  var eventTypes = {
+    change: {
+      phasedRegistrationNames: {
+        bubbled: keyOf({ onChange: null }),
+        captured: keyOf({ onChangeCapture: null })
+      },
+      dependencies: [topLevelTypes.topBlur, topLevelTypes.topChange, topLevelTypes.topClick, topLevelTypes.topFocus, topLevelTypes.topInput, topLevelTypes.topKeyDown, topLevelTypes.topKeyUp, topLevelTypes.topSelectionChange]
     }
-  },
+  };
 
   /**
-   * Resets the internal queue.
-   *
-   * @internal
+   * For IE shims
    */
-  reset: function() {
-    this._callbacks = null;
-    this._contexts = null;
-  },
+  var activeElement = null;
+  var activeElementID = null;
+  var activeElementValue = null;
+  var activeElementValueProp = null;
 
   /**
-   * `PooledClass` looks for this.
+   * SECTION: handle `change` event
    */
-  destructor: function() {
-    this.reset();
+  function shouldUseChangeEvent(elem) {
+    var nodeName = elem.nodeName && elem.nodeName.toLowerCase();
+    return nodeName === 'select' || nodeName === 'input' && elem.type === 'file';
   }
 
-});
+  var doesChangeEventBubble = false;
+  if (ExecutionEnvironment.canUseDOM) {
+    // See `handleChange` comment below
+    doesChangeEventBubble = isEventSupported('change') && (!('documentMode' in document) || document.documentMode > 8);
+  }
 
-PooledClass.addPoolingTo(CallbackQueue);
+  function manualDispatchChangeEvent(nativeEvent) {
+    var event = SyntheticEvent.getPooled(eventTypes.change, activeElementID, nativeEvent, getEventTarget(nativeEvent));
+    EventPropagators.accumulateTwoPhaseDispatches(event);
 
-module.exports = CallbackQueue;
+    // If change and propertychange bubbled, we'd just bind to it like all the
+    // other events and have it go through ReactBrowserEventEmitter. Since it
+    // doesn't, we manually listen for the events and so we have to enqueue and
+    // process the abstract event manually.
+    //
+    // Batching is necessary here in order to ensure that all event handlers run
+    // before the next rerender (including event handlers attached to ancestor
+    // elements instead of directly on the input). Without this, controlled
+    // components don't work properly in conjunction with event bubbling because
+    // the component is rerendered and the value reverted before all the event
+    // handlers can run. See https://github.com/facebook/react/issues/708.
+    ReactUpdates.batchedUpdates(runEventInBatch, event);
+  }
 
-},{"150":150,"29":29,"30":30}],8:[function(_dereq_,module,exports){
-/**
- * Copyright 2013-2015, 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.
- *
- * @providesModule ChangeEventPlugin
- */
+  function runEventInBatch(event) {
+    EventPluginHub.enqueueEvents(event);
+    EventPluginHub.processEventQueue(false);
+  }
 
-'use strict';
+  function startWatchingForChangeEventIE8(target, targetID) {
+    activeElement = target;
+    activeElementID = targetID;
+    activeElement.attachEvent('onchange', manualDispatchChangeEvent);
+  }
 
-var EventConstants = _dereq_(16);
-var EventPluginHub = _dereq_(18);
-var EventPropagators = _dereq_(21);
-var ExecutionEnvironment = _dereq_(22);
-var ReactUpdates = _dereq_(100);
-var SyntheticEvent = _dereq_(108);
+  function stopWatchingForChangeEventIE8() {
+    if (!activeElement) {
+      return;
+    }
+    activeElement.detachEvent('onchange', manualDispatchChangeEvent);
+    activeElement = null;
+    activeElementID = null;
+  }
 
-var isEventSupported = _dereq_(151);
-var isTextInputElement = _dereq_(153);
-var keyOf = _dereq_(157);
+  function getTargetIDForChangeEvent(topLevelType, topLevelTarget, topLevelTargetID) {
+    if (topLevelType === topLevelTypes.topChange) {
+      return topLevelTargetID;
+    }
+  }
+  function handleEventsForChangeEventIE8(topLevelType, topLevelTarget, topLevelTargetID) {
+    if (topLevelType === topLevelTypes.topFocus) {
+      // stopWatching() should be a noop here but we call it just in case we
+      // missed a blur event somehow.
+      stopWatchingForChangeEventIE8();
+      startWatchingForChangeEventIE8(topLevelTarget, topLevelTargetID);
+    } else if (topLevelType === topLevelTypes.topBlur) {
+      stopWatchingForChangeEventIE8();
+    }
+  }
 
-var topLevelTypes = EventConstants.topLevelTypes;
+  /**
+   * SECTION: handle `input` event
+   */
+  var isInputEventSupported = false;
+  if (ExecutionEnvironment.canUseDOM) {
+    // IE9 claims to support the input event but fails to trigger it when
+    // deleting text, so we ignore its input events
+    isInputEventSupported = isEventSupported('input') && (!('documentMode' in document) || document.documentMode > 9);
+  }
 
-var eventTypes = {
-  change: {
-    phasedRegistrationNames: {
-      bubbled: keyOf({onChange: null}),
-      captured: keyOf({onChangeCapture: null})
+  /**
+   * (For old IE.) Replacement getter/setter for the `value` property that gets
+   * set on the active element.
+   */
+  var newValueProp = {
+    get: function () {
+      return activeElementValueProp.get.call(this);
     },
-    dependencies: [
-      topLevelTypes.topBlur,
-      topLevelTypes.topChange,
-      topLevelTypes.topClick,
-      topLevelTypes.topFocus,
-      topLevelTypes.topInput,
-      topLevelTypes.topKeyDown,
-      topLevelTypes.topKeyUp,
-      topLevelTypes.topSelectionChange
-    ]
-  }
-};
+    set: function (val) {
+      // Cast to a string so we can do equality checks.
+      activeElementValue = '' + val;
+      activeElementValueProp.set.call(this, val);
+    }
+  };
 
-/**
- * For IE shims
- */
-var activeElement = null;
-var activeElementID = null;
-var activeElementValue = null;
-var activeElementValueProp = null;
+  /**
+   * (For old IE.) Starts tracking propertychange events on the passed-in element
+   * and override the value property so that we can distinguish user events from
+   * value changes in JS.
+   */
+  function startWatchingForValueChange(target, targetID) {
+    activeElement = target;
+    activeElementID = targetID;
+    activeElementValue = target.value;
+    activeElementValueProp = Object.getOwnPropertyDescriptor(target.constructor.prototype, 'value');
 
-/**
- * SECTION: handle `change` event
- */
-function shouldUseChangeEvent(elem) {
-  return (
-    elem.nodeName === 'SELECT' ||
-    (elem.nodeName === 'INPUT' && elem.type === 'file')
-  );
-}
-
-var doesChangeEventBubble = false;
-if (ExecutionEnvironment.canUseDOM) {
-  // See `handleChange` comment below
-  doesChangeEventBubble = isEventSupported('change') && (
-    (!('documentMode' in document) || document.documentMode > 8)
-  );
-}
-
-function manualDispatchChangeEvent(nativeEvent) {
-  var event = SyntheticEvent.getPooled(
-    eventTypes.change,
-    activeElementID,
-    nativeEvent
-  );
-  EventPropagators.accumulateTwoPhaseDispatches(event);
-
-  // If change and propertychange bubbled, we'd just bind to it like all the
-  // other events and have it go through ReactBrowserEventEmitter. Since it
-  // doesn't, we manually listen for the events and so we have to enqueue and
-  // process the abstract event manually.
-  //
-  // Batching is necessary here in order to ensure that all event handlers run
-  // before the next rerender (including event handlers attached to ancestor
-  // elements instead of directly on the input). Without this, controlled
-  // components don't work properly in conjunction with event bubbling because
-  // the component is rerendered and the value reverted before all the event
-  // handlers can run. See https://github.com/facebook/react/issues/708.
-  ReactUpdates.batchedUpdates(runEventInBatch, event);
-}
-
-function runEventInBatch(event) {
-  EventPluginHub.enqueueEvents(event);
-  EventPluginHub.processEventQueue();
-}
-
-function startWatchingForChangeEventIE8(target, targetID) {
-  activeElement = target;
-  activeElementID = targetID;
-  activeElement.attachEvent('onchange', manualDispatchChangeEvent);
-}
-
-function stopWatchingForChangeEventIE8() {
-  if (!activeElement) {
-    return;
-  }
-  activeElement.detachEvent('onchange', manualDispatchChangeEvent);
-  activeElement = null;
-  activeElementID = null;
-}
-
-function getTargetIDForChangeEvent(
-    topLevelType,
-    topLevelTarget,
-    topLevelTargetID) {
-  if (topLevelType === topLevelTypes.topChange) {
-    return topLevelTargetID;
-  }
-}
-function handleEventsForChangeEventIE8(
-    topLevelType,
-    topLevelTarget,
-    topLevelTargetID) {
-  if (topLevelType === topLevelTypes.topFocus) {
-    // stopWatching() should be a noop here but we call it just in case we
-    // missed a blur event somehow.
-    stopWatchingForChangeEventIE8();
-    startWatchingForChangeEventIE8(topLevelTarget, topLevelTargetID);
-  } else if (topLevelType === topLevelTypes.topBlur) {
-    stopWatchingForChangeEventIE8();
-  }
-}
+    // Not guarded in a canDefineProperty check: IE8 supports defineProperty only
+    // on DOM elements
+    Object.defineProperty(activeElement, 'value', newValueProp);
+    activeElement.attachEvent('onpropertychange', handlePropertyChange);
+  }
 
+  /**
+   * (For old IE.) Removes the event listeners from the currently-tracked element,
+   * if any exists.
+   */
+  function stopWatchingForValueChange() {
+    if (!activeElement) {
+      return;
+    }
 
-/**
- * SECTION: handle `input` event
- */
-var isInputEventSupported = false;
-if (ExecutionEnvironment.canUseDOM) {
-  // IE9 claims to support the input event but fails to trigger it when
-  // deleting text, so we ignore its input events
-  isInputEventSupported = isEventSupported('input') && (
-    (!('documentMode' in document) || document.documentMode > 9)
-  );
-}
+    // delete restores the original property definition
+    delete activeElement.value;
+    activeElement.detachEvent('onpropertychange', handlePropertyChange);
 
-/**
- * (For old IE.) Replacement getter/setter for the `value` property that gets
- * set on the active element.
- */
-var newValueProp =  {
-  get: function() {
-    return activeElementValueProp.get.call(this);
-  },
-  set: function(val) {
-    // Cast to a string so we can do equality checks.
-    activeElementValue = '' + val;
-    activeElementValueProp.set.call(this, val);
+    activeElement = null;
+    activeElementID = null;
+    activeElementValue = null;
+    activeElementValueProp = null;
   }
-};
 
-/**
- * (For old IE.) Starts tracking propertychange events on the passed-in element
- * and override the value property so that we can distinguish user events from
- * value changes in JS.
- */
-function startWatchingForValueChange(target, targetID) {
-  activeElement = target;
-  activeElementID = targetID;
-  activeElementValue = target.value;
-  activeElementValueProp = Object.getOwnPropertyDescriptor(
-    target.constructor.prototype,
-    'value'
-  );
-
-  Object.defineProperty(activeElement, 'value', newValueProp);
-  activeElement.attachEvent('onpropertychange', handlePropertyChange);
-}
+  /**
+   * (For old IE.) Handles a propertychange event, sending a `change` event if
+   * the value of the active element has changed.
+   */
+  function handlePropertyChange(nativeEvent) {
+    if (nativeEvent.propertyName !== 'value') {
+      return;
+    }
+    var value = nativeEvent.srcElement.value;
+    if (value === activeElementValue) {
+      return;
+    }
+    activeElementValue = value;
 
-/**
- * (For old IE.) Removes the event listeners from the currently-tracked element,
- * if any exists.
- */
-function stopWatchingForValueChange() {
-  if (!activeElement) {
-    return;
+    manualDispatchChangeEvent(nativeEvent);
   }
 
-  // delete restores the original property definition
-  delete activeElement.value;
-  activeElement.detachEvent('onpropertychange', handlePropertyChange);
-
-  activeElement = null;
-  activeElementID = null;
-  activeElementValue = null;
-  activeElementValueProp = null;
-}
-
-/**
- * (For old IE.) Handles a propertychange event, sending a `change` event if
- * the value of the active element has changed.
- */
-function handlePropertyChange(nativeEvent) {
-  if (nativeEvent.propertyName !== 'value') {
-    return;
-  }
-  var value = nativeEvent.srcElement.value;
-  if (value === activeElementValue) {
-    return;
+  /**
+   * If a `change` event should be fired, returns the target's ID.
+   */
+  function getTargetIDForInputEvent(topLevelType, topLevelTarget, topLevelTargetID) {
+    if (topLevelType === topLevelTypes.topInput) {
+      // In modern browsers (i.e., not IE8 or IE9), the input event is exactly
+      // what we want so fall through here and trigger an abstract event
+      return topLevelTargetID;
+    }
   }
-  activeElementValue = value;
-
-  manualDispatchChangeEvent(nativeEvent);
-}
 
-/**
- * If a `change` event should be fired, returns the target's ID.
- */
-function getTargetIDForInputEvent(
-    topLevelType,
-    topLevelTarget,
-    topLevelTargetID) {
-  if (topLevelType === topLevelTypes.topInput) {
-    // In modern browsers (i.e., not IE8 or IE9), the input event is exactly
-    // what we want so fall through here and trigger an abstract event
-    return topLevelTargetID;
+// For IE8 and IE9.
+  function handleEventsForInputEventIE(topLevelType, topLevelTarget, topLevelTargetID) {
+    if (topLevelType === topLevelTypes.topFocus) {
+      // In IE8, we can capture almost all .value changes by adding a
+      // propertychange handler and looking for events with propertyName
+      // equal to 'value'
+      // In IE9, propertychange fires for most input events but is buggy and
+      // doesn't fire when text is deleted, but conveniently, selectionchange
+      // appears to fire in all of the remaining cases so we catch those and
+      // forward the event if the value has changed
+      // In either case, we don't want to call the event handler if the value
+      // is changed from JS so we redefine a setter for `.value` that updates
+      // our activeElementValue variable, allowing us to ignore those changes
+      //
+      // stopWatching() should be a noop here but we call it just in case we
+      // missed a blur event somehow.
+      stopWatchingForValueChange();
+      startWatchingForValueChange(topLevelTarget, topLevelTargetID);
+    } else if (topLevelType === topLevelTypes.topBlur) {
+      stopWatchingForValueChange();
+    }
   }
-}
 
 // For IE8 and IE9.
-function handleEventsForInputEventIE(
-    topLevelType,
-    topLevelTarget,
-    topLevelTargetID) {
-  if (topLevelType === topLevelTypes.topFocus) {
-    // In IE8, we can capture almost all .value changes by adding a
-    // propertychange handler and looking for events with propertyName
-    // equal to 'value'
-    // In IE9, propertychange fires for most input events but is buggy and
-    // doesn't fire when text is deleted, but conveniently, selectionchange
-    // appears to fire in all of the remaining cases so we catch those and
-    // forward the event if the value has changed
-    // In either case, we don't want to call the event handler if the value
-    // is changed from JS so we redefine a setter for `.value` that updates
-    // our activeElementValue variable, allowing us to ignore those changes
-    //
-    // stopWatching() should be a noop here but we call it just in case we
-    // missed a blur event somehow.
-    stopWatchingForValueChange();
-    startWatchingForValueChange(topLevelTarget, topLevelTargetID);
-  } else if (topLevelType === topLevelTypes.topBlur) {
-    stopWatchingForValueChange();
+  function getTargetIDForInputEventIE(topLevelType, topLevelTarget, topLevelTargetID) {
+    if (topLevelType === topLevelTypes.topSelectionChange || topLevelType === topLevelTypes.topKeyUp || topLevelType === topLevelTypes.topKeyDown) {
+      // On the selectionchange event, the target is just document which isn't
+      // helpful for us so just check activeElement instead.
+      //
+      // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
+      // propertychange on the first input event after setting `value` from a
+      // script and fires only keydown, keypress, keyup. Catching keyup usually
+      // gets it and catching keydown lets us fire an event for the first
+      // keystroke if user does a key repeat (it'll be a little delayed: right
+      // before the second keystroke). Other input methods (e.g., paste) seem to
+      // fire selectionchange normally.
+      if (activeElement && activeElement.value !== activeElementValue) {
+        activeElementValue = activeElement.value;
+        return activeElementID;
+      }
+    }
   }
-}
 
-// For IE8 and IE9.
-function getTargetIDForInputEventIE(
-    topLevelType,
-    topLevelTarget,
-    topLevelTargetID) {
-  if (topLevelType === topLevelTypes.topSelectionChange ||
-      topLevelType === topLevelTypes.topKeyUp ||
-      topLevelType === topLevelTypes.topKeyDown) {
-    // On the selectionchange event, the target is just document which isn't
-    // helpful for us so just check activeElement instead.
-    //
-    // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
-    // propertychange on the first input event after setting `value` from a
-    // script and fires only keydown, keypress, keyup. Catching keyup usually
-    // gets it and catching keydown lets us fire an event for the first
-    // keystroke if user does a key repeat (it'll be a little delayed: right
-    // before the second keystroke). Other input methods (e.g., paste) seem to
-    // fire selectionchange normally.
-    if (activeElement && activeElement.value !== activeElementValue) {
-      activeElementValue = activeElement.value;
-      return activeElementID;
+  /**
+   * SECTION: handle `click` event
+   */
+  function shouldUseClickEvent(elem) {
+    // Use the `click` event to detect changes to checkbox and radio inputs.
+    // This approach works across all browsers, whereas `change` does not fire
+    // until `blur` in IE8.
+    return elem.nodeName && elem.nodeName.toLowerCase() === 'input' && (elem.type === 'checkbox' || elem.type === 'radio');
+  }
+
+  function getTargetIDForClickEvent(topLevelType, topLevelTarget, topLevelTargetID) {
+    if (topLevelType === topLevelTypes.topClick) {
+      return topLevelTargetID;
     }
   }
-}
 
+  /**
+   * This plugin creates an `onChange` event that normalizes change events
+   * across form elements. This event fires at a time when it's possible to
+   * change the element's value without seeing a flicker.
+   *
+   * Supported elements are:
+   * - input (see `isTextInputElement`)
+   * - textarea
+   * - select
+   */
+  var ChangeEventPlugin = {
 
-/**
- * SECTION: handle `click` event
- */
-function shouldUseClickEvent(elem) {
-  // Use the `click` event to detect changes to checkbox and radio inputs.
-  // This approach works across all browsers, whereas `change` does not fire
-  // until `blur` in IE8.
-  return (
-    elem.nodeName === 'INPUT' &&
-    (elem.type === 'checkbox' || elem.type === 'radio')
-  );
-}
-
-function getTargetIDForClickEvent(
-    topLevelType,
-    topLevelTarget,
-    topLevelTargetID) {
-  if (topLevelType === topLevelTypes.topClick) {
-    return topLevelTargetID;
-  }
-}
+    eventTypes: eventTypes,
 
-/**
- * This plugin creates an `onChange` event that normalizes change events
- * across form elements. This event fires at a time when it's possible to
- * change the element's value without seeing a flicker.
- *
- * Supported elements are:
- * - input (see `isTextInputElement`)
- * - textarea
- * - select
- */
-var ChangeEventPlugin = {
+    /**
+     * @param {string} topLevelType Record from `EventConstants`.
+     * @param {DOMEventTarget} topLevelTarget The listening component root node.
+     * @param {string} topLevelTargetID ID of `topLevelTarget`.
+     * @param {object} nativeEvent Native browser event.
+     * @return {*} An accumulation of synthetic events.
+     * @see {EventPluginHub.extractEvents}
+     */
+    extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) {
 
-  eventTypes: eventTypes,
+      var getTargetIDFunc, handleEventFunc;
+      if (shouldUseChangeEvent(topLevelTarget)) {
+        if (doesChangeEventBubble) {
+          getTargetIDFunc = getTargetIDForChangeEvent;
+        } else {
+          handleEventFunc = handleEventsForChangeEventIE8;
+        }
+      } else if (isTextInputElement(topLevelTarget)) {
+        if (isInputEventSupported) {
+          getTargetIDFunc = getTargetIDForInputEvent;
+        } else {
+          getTargetIDFunc = getTargetIDForInputEventIE;
+          handleEventFunc = handleEventsForInputEventIE;
+        }
+      } else if (shouldUseClickEvent(topLevelTarget)) {
+        getTargetIDFunc = getTargetIDForClickEvent;
+      }
 
-  /**
-   * @param {string} topLevelType Record from `EventConstants`.
-   * @param {DOMEventTarget} topLevelTarget The listening component root node.
-   * @param {string} topLevelTargetID ID of `topLevelTarget`.
-   * @param {object} nativeEvent Native browser event.
-   * @return {*} An accumulation of synthetic events.
-   * @see {EventPluginHub.extractEvents}
-   */
-  extractEvents: function(
-      topLevelType,
-      topLevelTarget,
-      topLevelTargetID,
-      nativeEvent) {
-
-    var getTargetIDFunc, handleEventFunc;
-    if (shouldUseChangeEvent(topLevelTarget)) {
-      if (doesChangeEventBubble) {
-        getTargetIDFunc = getTargetIDForChangeEvent;
-      } else {
-        handleEventFunc = handleEventsForChangeEventIE8;
+      if (getTargetIDFunc) {
+        var targetID = getTargetIDFunc(topLevelType, topLevelTarget, topLevelTargetID);
+        if (targetID) {
+          var event = SyntheticEvent.getPooled(eventTypes.change, targetID, nativeEvent, nativeEventTarget);
+          event.type = 'change';
+          EventPropagators.accumulateTwoPhaseDispatches(event);
+          return event;
+        }
       }
-    } else if (isTextInputElement(topLevelTarget)) {
-      if (isInputEventSupported) {
-        getTargetIDFunc = getTargetIDForInputEvent;
-      } else {
-        getTargetIDFunc = getTargetIDForInputEventIE;
-        handleEventFunc = handleEventsForInputEventIE;
+
+      if (handleEventFunc) {
+        handleEventFunc(topLevelType, topLevelTarget, topLevelTargetID);
       }
-    } else if (shouldUseClickEvent(topLevelTarget)) {
-      getTargetIDFunc = getTargetIDForClickEvent;
     }
 
-    if (getTargetIDFunc) {
-      var targetID = getTargetIDFunc(
-        topLevelType,
-        topLevelTarget,
-        topLevelTargetID
-      );
-      if (targetID) {
-        var event = SyntheticEvent.getPooled(
-          eventTypes.change,
-          targetID,
-          nativeEvent
-        );
-        EventPropagators.accumulateTwoPhaseDispatches(event);
-        return event;
-      }
-    }
-
-    if (handleEventFunc) {
-      handleEventFunc(
-        topLevelType,
-        topLevelTarget,
-        topLevelTargetID
-      );
-    }
-  }
-
-};
-
-module.exports = ChangeEventPlugin;
-
-},{"100":100,"108":108,"151":151,"153":153,"157":157,"16":16,"18":18,"21":21,"22":22}],9:[function(_dereq_,module,exports){
-/**
- * Copyright 2013-2015, 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.
- *
- * @providesModule ClientReactRootIndex
- * @typechecks
- */
-
-'use strict';
-
-var nextReactRootIndex = 0;
-
-var ClientReactRootIndex = {
-  createReactRootIndex: function() {
-    return nextReactRootIndex++;
-  }
-};
-
-module.exports = ClientReactRootIndex;
+  };
 
-},{}],10:[function(_dereq_,module,exports){
-/**
- * Copyright 2013-2015, 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 ad

<TRUNCATED>

Mime
View raw message