From 0c6f4b3bcc8dc728f4736e53e3d81d6ae4c47cb9 Mon Sep 17 00:00:00 2001
From: Ben Alpert <spicyjalapeno@gmail.com>
Date: Wed, 12 Jun 2013 00:14:58 -0700
Subject: [PATCH 01/94] Set textarea value when changing content

At http://jsfiddle.net/spicyj/W4QLq/, typing into the textbox would cause
clicking the button to do nothing; now it should work.
---
 src/core/ReactDOM.js                        |  1 +
 src/core/ReactDOMTextarea.js                | 63 ++++++++++++++++++++
 src/core/ReactDefaultInjection.js           |  4 +-
 src/core/__tests__/ReactDOMTextarea-test.js | 66 +++++++++++++++++++++
 4 files changed, 133 insertions(+), 1 deletion(-)
 create mode 100644 src/core/ReactDOMTextarea.js
 create mode 100644 src/core/__tests__/ReactDOMTextarea-test.js

diff --git a/src/core/ReactDOM.js b/src/core/ReactDOM.js
index 2fe78e99a7..a3c470c1ce 100644
--- a/src/core/ReactDOM.js
+++ b/src/core/ReactDOM.js
@@ -115,6 +115,7 @@ var ReactDOM = objMapKeyVal({
   table: false,
   tbody: false,
   td: false,
+  // Danger: this gets monkeypatched! See ReactDOMTextarea for more info.
   textarea: false,
   tfoot: false,
   th: false,
diff --git a/src/core/ReactDOMTextarea.js b/src/core/ReactDOMTextarea.js
new file mode 100644
index 0000000000..d193d7cffe
--- /dev/null
+++ b/src/core/ReactDOMTextarea.js
@@ -0,0 +1,63 @@
+/**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @providesModule ReactDOMTextarea
+ */
+
+"use strict";
+
+var ReactCompositeComponent = require('ReactCompositeComponent');
+var ReactDOM = require('ReactDOM');
+
+var invariant = require('invariant');
+
+// Store a reference to the <textarea> `ReactNativeComponent`.
+var textarea = ReactDOM.textarea;
+
+// For quickly matching children type, to test if can be treated as content.
+var CONTENT_TYPES = {'string': true, 'number': true};
+
+var getTextContent = function(props) {
+  return props.content != null ? '' + props.content :
+    CONTENT_TYPES[typeof props.children] ? '' + props.children : '';
+};
+
+/**
+ * Since setting .textContent on a dirty <textarea> doesn't update its value,
+ * we intercept prop changes here to make sure that value is updated.
+ */
+var ReactDOMTextarea = ReactCompositeComponent.createClass({
+  render: function() {
+    invariant(
+      this.props.dangerouslySetInnerHTML == null,
+      '`dangerouslySetInnerHTML` does not make sense on textarea.'
+    );
+    invariant(
+      this.props.children == null || CONTENT_TYPES[typeof this.props.children],
+      'When present, textarea children must be a single string or number.'
+    );
+    return this.transferPropsTo(textarea(null, this.props.children));
+  },
+
+  componentDidUpdate: function(prevProps, prevState, rootNode) {
+    var oldContent = getTextContent(prevProps);
+    var newContent = getTextContent(this.props);
+    if (oldContent !== newContent) {
+      rootNode.value = newContent;
+    }
+  }
+});
+
+module.exports = ReactDOMTextarea;
diff --git a/src/core/ReactDefaultInjection.js b/src/core/ReactDefaultInjection.js
index 75044d849f..4e68d8fa6b 100644
--- a/src/core/ReactDefaultInjection.js
+++ b/src/core/ReactDefaultInjection.js
@@ -20,6 +20,7 @@
 
 var ReactDOM = require('ReactDOM');
 var ReactDOMForm = require('ReactDOMForm');
+var ReactDOMTextarea = require('ReactDOMTextarea');
 
 var DefaultEventPluginOrder = require('DefaultEventPluginOrder');
 var EnterLeaveEventPlugin = require('EnterLeaveEventPlugin');
@@ -50,7 +51,8 @@ function inject() {
    * dependency graph we need to inject it here.
    */
   ReactDOM.injection.injectComponentClasses({
-    form: ReactDOMForm
+    form: ReactDOMForm,
+    textarea: ReactDOMTextarea
   });
 }
 
diff --git a/src/core/__tests__/ReactDOMTextarea-test.js b/src/core/__tests__/ReactDOMTextarea-test.js
new file mode 100644
index 0000000000..00f7bed92d
--- /dev/null
+++ b/src/core/__tests__/ReactDOMTextarea-test.js
@@ -0,0 +1,66 @@
+/**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @jsx React.DOM
+ * @emails react-core
+ */
+
+"use strict";
+
+describe('ReactDOMTextarea', function() {
+  var React;
+  var ReactTestUtils;
+  var transaction;
+
+  beforeEach(function() {
+    React = require('React');
+    ReactTestUtils = require('ReactTestUtils');
+
+    var ReactReconcileTransaction = require('ReactReconcileTransaction');
+    transaction = new ReactReconcileTransaction();
+  });
+
+  it("should remove value with removed children", function() {
+    var stub = ReactTestUtils.renderIntoDocument(<textarea>giraffe</textarea>);
+
+    expect(stub.getDOMNode().value).toEqual('giraffe');
+    stub.receiveProps({ children: null }, transaction);
+    expect(stub.getDOMNode().value).toEqual('');
+  });
+
+  it("should update value with a single string child", function() {
+    var stub = ReactTestUtils.renderIntoDocument(<textarea>monkey</textarea>);
+
+    expect(stub.getDOMNode().value).toEqual('monkey');
+    stub.receiveProps({ children: 'gorilla' }, transaction);
+    expect(stub.getDOMNode().value).toEqual('gorilla');
+  });
+
+  it("should update value with a single numerical child", function() {
+    var stub = ReactTestUtils.renderIntoDocument(<textarea>17</textarea>);
+
+    expect(stub.getDOMNode().value).toEqual('17');
+    stub.receiveProps({ children: 289 }, transaction);
+    expect(stub.getDOMNode().value).toEqual('289');
+  });
+
+  it("should update value with the content property", function() {
+    var stub = ReactTestUtils.renderIntoDocument(<textarea content="purple" />);
+
+    expect(stub.getDOMNode().value).toEqual('purple');
+    stub.receiveProps({ content: 'eggplant' }, transaction);
+    expect(stub.getDOMNode().value).toEqual('eggplant');
+  });
+});

From d13a37ce22503fc476a3a008be3ed31b418e283f Mon Sep 17 00:00:00 2001
From: Ben Alpert <spicyjalapeno@gmail.com>
Date: Wed, 12 Jun 2013 01:55:26 -0700
Subject: [PATCH 02/94] Don't set value if it'll be a noop

---
 src/core/ReactDOMTextarea.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/ReactDOMTextarea.js b/src/core/ReactDOMTextarea.js
index d193d7cffe..f7c9eaae30 100644
--- a/src/core/ReactDOMTextarea.js
+++ b/src/core/ReactDOMTextarea.js
@@ -54,7 +54,7 @@ var ReactDOMTextarea = ReactCompositeComponent.createClass({
   componentDidUpdate: function(prevProps, prevState, rootNode) {
     var oldContent = getTextContent(prevProps);
     var newContent = getTextContent(this.props);
-    if (oldContent !== newContent) {
+    if (oldContent !== newContent && rootNode.value !== newContent) {
       rootNode.value = newContent;
     }
   }

From d7a5f137ffdbb1e704c7d0d1108cc4bf09f0a4e2 Mon Sep 17 00:00:00 2001
From: Vjeux <vjeuxx@gmail.com>
Date: Thu, 13 Jun 2013 01:00:38 +0200
Subject: [PATCH 03/94] Adding JSX pitfalls section in the docs

---
 docs/_includes/nav_docs.html |  7 +++
 docs/docs/api.md             |  1 +
 docs/docs/jsx-is-not-html.md | 95 ++++++++++++++++++++++++++++++++++++
 3 files changed, 103 insertions(+)
 create mode 100644 docs/docs/jsx-is-not-html.md

diff --git a/docs/_includes/nav_docs.html b/docs/_includes/nav_docs.html
index d6d9e945a9..1dbd3b5c91 100644
--- a/docs/_includes/nav_docs.html
+++ b/docs/_includes/nav_docs.html
@@ -21,4 +21,11 @@
       <li><a href="/react/docs/api.html"{% if page.id == 'docs-api' %} class="active"{% endif %}>API</a></li>
     </ul>
   </div>
+
+  <div class="nav-docs-section">
+    <h3>Appendix</h3>
+    <ul>
+      <li><a href="/react/docs/jsx-is-not-html.html"{% if page.id == 'docs-jsx-is-not-html' %} class="active"{% endif %}>JSX is not HTML</a></li>
+    </ul>
+  </div>
 </div>
diff --git a/docs/docs/api.md b/docs/docs/api.md
index fd29070ecb..f8b9edda7e 100644
--- a/docs/docs/api.md
+++ b/docs/docs/api.md
@@ -3,6 +3,7 @@ id: docs-api
 title: React API
 layout: docs
 prev: mixins.html
+next: jsx-is-not-html.html
 ---
 
 ## React
diff --git a/docs/docs/jsx-is-not-html.md b/docs/docs/jsx-is-not-html.md
new file mode 100644
index 0000000000..e3c4126328
--- /dev/null
+++ b/docs/docs/jsx-is-not-html.md
@@ -0,0 +1,95 @@
+---
+id: docs-jsx-is-not-html
+title: JSX is not HTML
+description: Differences between JSX and HTML.
+layout: docs
+prev: api.html
+---
+
+JSX looks like HTML but there are some important differences you may run into.
+
+## Whitespace removal
+
+JSX doesn't follow the same whitespace elimination rules as HTML. JSX removes all the whitespaces between two curly braces expressions. If you want to have a white space, a work-around is to add `{' '}`.
+
+```javascript
+<div>{this.props.name} {' '} {this.props.surname}</div>
+```
+
+This behavior is still being debated. Follow [Issue #65](https://github.com/facebook/react/issues/65) to be updated on the situation.
+
+## HTML Entities
+
+You can insert HTML entities within literal text in JSX:
+
+```javascript
+<div>First &middot; Second</div>
+```
+
+If you want to display an HTML entity within a dynamic content, you will run into double escaping issues as React escapes all the strings you are displaying in order to prevent a wide range of XSS attacks by default.
+
+```javascript
+// Bad: It displays "First &middot; Second"
+<div>{'First &middot; Second'}</div>
+```
+
+There are various ways to work-around this issue. The easiest one is to write unicode character directly in Javascript. You've got to make sure that the file is saved as UTF-8 and that the propers UTF-8 directives are set so the browser will display it correctly.
+
+```javascript
+<div>{'First · Second'}</div>
+```
+
+A safer alternative is to find the <a href="http://www.fileformat.info/info/unicode/char/b7/index.htm">unicode number corresponding to the entity</a> and use it inside of a Javascript string.
+
+```javascript
+<div>{'First \u00b7 Second'}</div>
+<div>{'First ' + String.fromCharCode(183) + ' Second'}</div>
+```
+
+You can use mixed arrays with strings and JSX elements.
+
+```javascript
+<div>{['First ', <span>&middot;</span>, ' Second']}</div>
+```
+
+In last resort, you always have the ability to insert raw HTML inside of the div.
+
+```javascript
+<div dangerouslySetInnerHTML={{'{{'}}__html: 'First &middot; Second'}} />
+```
+
+## Comments
+
+JSX supports both single-line and multi-lines Javascript comments within a tag declaration:
+
+```javascript
+<div // This is a single line comment:
+    /*
+        And a multiline
+        comment
+    */
+/>
+```
+
+As of React 0.3, there is no good way to insert comments within the children section. [Issue #82](https://github.com/facebook/react/issues/82) is tracking progress to enable the following way to write comments:
+
+```javascript
+// Note: The following is not implemented yet!
+<div>
+  {/* This is a comment */}
+</div>
+```
+
+## Custom HTML attributes
+
+If you pass properties to native HTML elements that do not exist in the HTML specification, React will not render them. If you want to use a custom attribute, you should prefix it with `data-`.
+
+```javascript
+<div data-custom-attribute="foo" />
+```
+
+[Web Accessibility](http://www.w3.org/WAI/intro/aria) attributes starting with `aria-` will be rendered properly.
+
+```javascript
+<div aria-hidden={true} />
+```

From ddc4ffffa06a531becb04f4c30b9dd91c5301c53 Mon Sep 17 00:00:00 2001
From: Ben Alpert <spicyjalapeno@gmail.com>
Date: Wed, 12 Jun 2013 19:12:52 -0700
Subject: [PATCH 04/94] Don't let textarea value change via textContent

Turns out my tests before weren't particularly useful because
receiveProps doesn't end up running componentDidUpdate since the
transaction never finishes. Now they use replaceProps instead (and I
verified that commenting out the "rootNode.value = ..." line makes the
tests fail, which wasn't true before).
---
 src/core/ReactDOMTextarea.js                | 16 ++++++++++++++--
 src/core/__tests__/ReactDOMTextarea-test.js | 11 ++++-------
 2 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/src/core/ReactDOMTextarea.js b/src/core/ReactDOMTextarea.js
index f7c9eaae30..f484da01cb 100644
--- a/src/core/ReactDOMTextarea.js
+++ b/src/core/ReactDOMTextarea.js
@@ -39,6 +39,16 @@ var getTextContent = function(props) {
  * we intercept prop changes here to make sure that value is updated.
  */
 var ReactDOMTextarea = ReactCompositeComponent.createClass({
+  getInitialState: function() {
+    // We keep the original value of content and children here so that
+    // ReactNativeComponent doesn't update textContent (unnecessary since we
+    // update value).
+    return {
+      initialContent: this.props.content,
+      initialChildren: this.props.children
+    };
+  },
+
   render: function() {
     invariant(
       this.props.dangerouslySetInnerHTML == null,
@@ -48,13 +58,15 @@ var ReactDOMTextarea = ReactCompositeComponent.createClass({
       this.props.children == null || CONTENT_TYPES[typeof this.props.children],
       'When present, textarea children must be a single string or number.'
     );
-    return this.transferPropsTo(textarea(null, this.props.children));
+    return this.transferPropsTo(textarea({
+      content: this.state.initialContent
+    }, this.state.initialChildren));
   },
 
   componentDidUpdate: function(prevProps, prevState, rootNode) {
     var oldContent = getTextContent(prevProps);
     var newContent = getTextContent(this.props);
-    if (oldContent !== newContent && rootNode.value !== newContent) {
+    if (oldContent !== newContent) {
       rootNode.value = newContent;
     }
   }
diff --git a/src/core/__tests__/ReactDOMTextarea-test.js b/src/core/__tests__/ReactDOMTextarea-test.js
index 00f7bed92d..1fb6d97820 100644
--- a/src/core/__tests__/ReactDOMTextarea-test.js
+++ b/src/core/__tests__/ReactDOMTextarea-test.js
@@ -27,16 +27,13 @@ describe('ReactDOMTextarea', function() {
   beforeEach(function() {
     React = require('React');
     ReactTestUtils = require('ReactTestUtils');
-
-    var ReactReconcileTransaction = require('ReactReconcileTransaction');
-    transaction = new ReactReconcileTransaction();
   });
 
   it("should remove value with removed children", function() {
     var stub = ReactTestUtils.renderIntoDocument(<textarea>giraffe</textarea>);
 
     expect(stub.getDOMNode().value).toEqual('giraffe');
-    stub.receiveProps({ children: null }, transaction);
+    stub.replaceProps({ children: null });
     expect(stub.getDOMNode().value).toEqual('');
   });
 
@@ -44,7 +41,7 @@ describe('ReactDOMTextarea', function() {
     var stub = ReactTestUtils.renderIntoDocument(<textarea>monkey</textarea>);
 
     expect(stub.getDOMNode().value).toEqual('monkey');
-    stub.receiveProps({ children: 'gorilla' }, transaction);
+    stub.replaceProps({ children: 'gorilla' });
     expect(stub.getDOMNode().value).toEqual('gorilla');
   });
 
@@ -52,7 +49,7 @@ describe('ReactDOMTextarea', function() {
     var stub = ReactTestUtils.renderIntoDocument(<textarea>17</textarea>);
 
     expect(stub.getDOMNode().value).toEqual('17');
-    stub.receiveProps({ children: 289 }, transaction);
+    stub.replaceProps({ children: 289 });
     expect(stub.getDOMNode().value).toEqual('289');
   });
 
@@ -60,7 +57,7 @@ describe('ReactDOMTextarea', function() {
     var stub = ReactTestUtils.renderIntoDocument(<textarea content="purple" />);
 
     expect(stub.getDOMNode().value).toEqual('purple');
-    stub.receiveProps({ content: 'eggplant' }, transaction);
+    stub.replaceProps({ content: 'eggplant' });
     expect(stub.getDOMNode().value).toEqual('eggplant');
   });
 });

From f01647928973e5944a4fcf4bd30d095d26ba6119 Mon Sep 17 00:00:00 2001
From: Greg Roodt <groodt@gmail.com>
Date: Sat, 15 Jun 2013 10:15:42 +0300
Subject: [PATCH 05/94] Update tutorial.md

The ajax call happens every 5 seconds, not every 60 seconds.
---
 docs/docs/tutorial.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/docs/tutorial.md b/docs/docs/tutorial.md
index 8117b2baaa..bc5b02c56c 100644
--- a/docs/docs/tutorial.md
+++ b/docs/docs/tutorial.md
@@ -435,7 +435,7 @@ React.renderComponent(
 
 ```
 
-All we have done here is move the AJAX call to a separate method and call it when the component is first loaded and every 60 seconds after that. Try running this in your browser and changing the `comments.json` file; within 5 seconds, the changes will show!
+All we have done here is move the AJAX call to a separate method and call it when the component is first loaded and every 5 seconds after that. Try running this in your browser and changing the `comments.json` file; within 5 seconds, the changes will show!
 
 ## Adding new comments
 

From 8d729d7da27be8645a6ded53c466907e482b68ee Mon Sep 17 00:00:00 2001
From: Greg Roodt <groodt@gmail.com>
Date: Sat, 15 Jun 2013 11:07:20 +0300
Subject: [PATCH 06/94] Minor typo.

---
 docs/docs/syntax.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/docs/syntax.md b/docs/docs/syntax.md
index e4b099bd23..bb477e9a07 100644
--- a/docs/docs/syntax.md
+++ b/docs/docs/syntax.md
@@ -53,7 +53,7 @@ var app = Nav({color:'blue'}, Profile({}, 'click'));
 ```
 
 Use the [JSX Compiler](/react/jsx-compiler.html) to try out JSX and see how it
-desguars into native JavaScript.
+desugars into native JavaScript.
 
 If you want to use JSX, the [Getting Started](getting-started.html) guide shows
 how to setup compilation.

From 87f4b8be679f86a6777e314f58edbe7f2fea22d9 Mon Sep 17 00:00:00 2001
From: Greg Roodt <groodt@gmail.com>
Date: Sat, 15 Jun 2013 11:08:06 +0300
Subject: [PATCH 07/94] Minor grammar.

---
 docs/docs/component-lifecycle.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/docs/component-lifecycle.md b/docs/docs/component-lifecycle.md
index 1998f1806e..8861c1877f 100644
--- a/docs/docs/component-lifecycle.md
+++ b/docs/docs/component-lifecycle.md
@@ -22,7 +22,7 @@ In this one simple line, we have accomplished the following:
  - The component is **mounted** into `document.body`.
 
 **Mounting** is the process of initializing a React component by creating its
-DOM nodes and inserting the them into a supplied container node.
+DOM nodes and inserting them into a supplied container node.
 
 At this point, the entire page consists of a single `<div>` with "Hello,
 world!".

From 4104beadbb0e8921a8f8ecffcbf29f8283e22de1 Mon Sep 17 00:00:00 2001
From: Ben Alpert <spicyjalapeno@gmail.com>
Date: Sat, 15 Jun 2013 18:59:45 -0600
Subject: [PATCH 08/94] Link to my own blog

---
 docs/_posts/2013-06-12-community-roundup.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/_posts/2013-06-12-community-roundup.md b/docs/_posts/2013-06-12-community-roundup.md
index f5e63a098b..d37e3b1351 100644
--- a/docs/_posts/2013-06-12-community-roundup.md
+++ b/docs/_posts/2013-06-12-community-roundup.md
@@ -8,14 +8,14 @@ React was open sourced two weeks ago and it's time for a little round-up of what
 
 ## Khan Academy Question Editor
 
-It looks like [Ben Alpert](http://benalpert.com/) is the first person outside of Facebook and Instagram to push React code to production. We are very grateful for his contributions in form of pull requests, bug reports and presence on IRC ([#reactjs on Freenode](irc://chat.freenode.net/reactjs)). Ben wrote about his experience using React on Quora:
+It looks like [Ben Alpert](http://benalpert.com/) is the first person outside of Facebook and Instagram to push React code to production. We are very grateful for his contributions in form of pull requests, bug reports and presence on IRC ([#reactjs on Freenode](irc://chat.freenode.net/reactjs)). Ben wrote about his experience using React:
 
 > I just rewrote a 2000-line project in React and have now made a handful of pull requests to React. Everything about React I've seen so far seems really well thought-out and I'm proud to be the first non-FB/IG production user of React.
 >
 > The project that I rewrote in React (and am continuing to improve) is the Khan Academy question editor which content creators can use to enter questions and hints that will be presented to students:
-> <figure>[![](/react/img/blog/khan-academy-editor.png)](http://www.quora.com/React-JS-Library/How-is-Facebooks-React-JavaScript-library/answer/Ben-Alpert)</figure>
+> <figure>[![](/react/img/blog/khan-academy-editor.png)](http://benalpert.com/2013/06/09/using-react-to-speed-up-khan-academy.html)</figure>
 >
-> [Read the full post...](http://www.quora.com/React-JS-Library/How-is-Facebooks-React-JavaScript-library/answer/Ben-Alpert)
+> [Read the full post...](http://benalpert.com/2013/06/09/using-react-to-speed-up-khan-academy.html)
 
 ## Pimp my Backbone.View (by replacing it with React)
 

From fad7d58fc9ef8da03acc6f4d1a11a2844f4cd2ce Mon Sep 17 00:00:00 2001
From: petehunt <pete.hunt@fb.com>
Date: Mon, 17 Jun 2013 03:11:57 -0600
Subject: [PATCH 09/94] Update jsx-is-not-html.md

---
 docs/docs/jsx-is-not-html.md | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/docs/docs/jsx-is-not-html.md b/docs/docs/jsx-is-not-html.md
index e3c4126328..084c97197b 100644
--- a/docs/docs/jsx-is-not-html.md
+++ b/docs/docs/jsx-is-not-html.md
@@ -10,13 +10,13 @@ JSX looks like HTML but there are some important differences you may run into.
 
 ## Whitespace removal
 
-JSX doesn't follow the same whitespace elimination rules as HTML. JSX removes all the whitespaces between two curly braces expressions. If you want to have a white space, a work-around is to add `{' '}`.
+JSX doesn't follow the same whitespace elimination rules as HTML. JSX removes all whitespace between two curly braces expressions. If you want to have whitespace, simply add `{' '}`.
 
 ```javascript
 <div>{this.props.name} {' '} {this.props.surname}</div>
 ```
 
-This behavior is still being debated. Follow [Issue #65](https://github.com/facebook/react/issues/65) to be updated on the situation.
+Follow [Issue #65](https://github.com/facebook/react/issues/65) for discussion on this behavior.
 
 ## HTML Entities
 
@@ -26,20 +26,20 @@ You can insert HTML entities within literal text in JSX:
 <div>First &middot; Second</div>
 ```
 
-If you want to display an HTML entity within a dynamic content, you will run into double escaping issues as React escapes all the strings you are displaying in order to prevent a wide range of XSS attacks by default.
+If you want to display an HTML entity within dynamic content, you will run into double escaping issues as React escapes all the strings you are displaying in order to prevent a wide range of XSS attacks by default.
 
 ```javascript
 // Bad: It displays "First &middot; Second"
 <div>{'First &middot; Second'}</div>
 ```
 
-There are various ways to work-around this issue. The easiest one is to write unicode character directly in Javascript. You've got to make sure that the file is saved as UTF-8 and that the propers UTF-8 directives are set so the browser will display it correctly.
+There are various ways to work-around this issue. The easiest one is to write unicode character directly in Javascript. You need to make sure that the file is saved as UTF-8 and that the proper UTF-8 directives are set so the browser will display it correctly.
 
 ```javascript
 <div>{'First · Second'}</div>
 ```
 
-A safer alternative is to find the <a href="http://www.fileformat.info/info/unicode/char/b7/index.htm">unicode number corresponding to the entity</a> and use it inside of a Javascript string.
+A safer alternative is to find the [unicode number corresponding to the entity](http://www.fileformat.info/info/unicode/char/b7/index.htm) and use it inside of a JavaScript string.
 
 ```javascript
 <div>{'First \u00b7 Second'}</div>
@@ -52,29 +52,29 @@ You can use mixed arrays with strings and JSX elements.
 <div>{['First ', <span>&middot;</span>, ' Second']}</div>
 ```
 
-In last resort, you always have the ability to insert raw HTML inside of the div.
+As a last resort, you always have the ability to insert raw HTML.
 
 ```javascript
-<div dangerouslySetInnerHTML={{'{{'}}__html: 'First &middot; Second'}} />
+<div dangerouslySetInnerHTML={{__html: 'First &middot; Second'}} />
 ```
 
 ## Comments
 
-JSX supports both single-line and multi-lines Javascript comments within a tag declaration:
+JSX supports both single-line and multi-line JavaScript comments within a tag declaration:
 
 ```javascript
-<div // This is a single line comment:
+<div // This is a single-line comment:
     /*
-        And a multiline
+        And a multi-line
         comment
     */
 />
 ```
 
-As of React 0.3, there is no good way to insert comments within the children section. [Issue #82](https://github.com/facebook/react/issues/82) is tracking progress to enable the following way to write comments:
+As of React 0.3, there is no good way to insert comments within the children section. [Issue #82](https://github.com/facebook/react/issues/82) is tracking progress to enable the following:
 
 ```javascript
-// Note: The following is not implemented yet!
+// Note: This is not implemented yet!
 <div>
   {/* This is a comment */}
 </div>

From c79a59b5998d16b245fd970b7356c217c9c6e937 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Paul=20O=E2=80=99Shannessy?= <paul@oshannessy.com>
Date: Mon, 17 Jun 2013 10:52:16 -0700
Subject: [PATCH 10/94] Improve JSXTransformer

The biggest improvement is that we'll now insert each parsed JSX script
back into a `<script>` tag with the body set. This allows the browser to
execute these scripts normally. Using `Function(functionBody)` or
`eval(functionBody)` both execute in window scope, but `var` assignments
don't actually get set on window (unlike everywhere else).

I also did some cleanup to make the code a little bit more readable.
In my minimal test cases this didn't break anything (scripts loaded in
the right order).
---
 vendor/browser-transforms.js | 68 ++++++++++++++----------------------
 1 file changed, 26 insertions(+), 42 deletions(-)

diff --git a/vendor/browser-transforms.js b/vendor/browser-transforms.js
index c241804f3c..c2a37c0a50 100644
--- a/vendor/browser-transforms.js
+++ b/vendor/browser-transforms.js
@@ -24,22 +24,22 @@ var visitors = require('./fbtransform/visitors').transformVisitors;
 var transform = transform.bind(null, visitors.react);
 var docblock = require('./fbtransform/lib/docblock');
 
+var headEl = document.getElementsByTagName('head')[0];
+
 exports.transform = transform;
+
 exports.exec = function(code) {
   return eval(transform(code));
 };
-var run = exports.run = function(code) {
-  var moduleName =
-    docblock.parseAsObject(docblock.extract(code)).providesModule;
-  var jsx =
-    docblock.parseAsObject(docblock.extract(code)).jsx;
 
-  window.moduleLoads = (window.moduleLoads || []).concat(moduleName);
-  window.startTime = Date.now();
+var run = exports.run = function(code) {
+  var jsx = docblock.parseAsObject(docblock.extract(code)).jsx;
+
   var functionBody = jsx ? transform(code).code : code;
-  Function('require', 'module', 'exports', functionBody)(require, module, exports);
-  window.endTime = Date.now();
-  require[moduleName] = module.exports;
+  var scriptEl = document.createElement('script');
+
+  scriptEl.innerHTML = functionBody;
+  headEl.appendChild(scriptEl);
 };
 
 if (typeof window === "undefined" || window === null) {
@@ -48,15 +48,17 @@ if (typeof window === "undefined" || window === null) {
 
 var load = exports.load = function(url, callback) {
   var xhr;
-  xhr = window.ActiveXObject ? new window.ActiveXObject('Microsoft.XMLHTTP') : new XMLHttpRequest();
+  xhr = window.ActiveXObject ? new window.ActiveXObject('Microsoft.XMLHTTP')
+                             : new XMLHttpRequest();
+  // Disable async since we need to execute scripts in the order they are in the
+  // DOM to mirror normal script loading.
   xhr.open('GET', url, false);
   if ('overrideMimeType' in xhr) {
     xhr.overrideMimeType('text/plain');
   }
   xhr.onreadystatechange = function() {
-    var _ref;
     if (xhr.readyState === 4) {
-      if ((_ref = xhr.status) === 0 || _ref === 200) {
+      if (xhr.status === 0 || xhr.status === 200) {
         run(xhr.responseText);
       } else {
         throw new Error("Could not load " + url);
@@ -70,37 +72,19 @@ var load = exports.load = function(url, callback) {
 };
 
 runScripts = function() {
-  var jsxes, execute, index, length, s, scripts;
-  scripts = document.getElementsByTagName('script');
-  jsxes = (function() {
-    var _i, _len, _results;
-    _results = [];
-    for (_i = 0, _len = scripts.length; _i < _len; _i++) {
-      s = scripts[_i];
-      if (s.type === 'text/jsx') {
-        _results.push(s);
-      }
-    }
-    return _results;
-  })();
-  index = 0;
-  length = jsxes.length;
-  (execute = function(j) {
-    var script;
-    script = jsxes[j];
-    if ((script != null ? script.type : void 0) === 'text/jsx') {
-      if (script.src) {
-         return load(script.src, execute);
-      } else {
-        run(script.innerHTML);
-        return execute();
-      }
+  var scripts = document.getElementsByTagName('script');
+  scripts = Array.prototype.slice.call(scripts);
+  var jsxScripts = scripts.filter(function(script) {
+    return script.type === 'text/jsx';
+  });
+
+  jsxScripts.forEach(function(script) {
+    if (script.src) {
+      load(script.src);
+    } else {
+      run(script.innerHTML);
     }
   });
-  for (var i = 0; i < jsxes.length; i++) {
-    execute(i);
-  }
-  return null;
 };
 
 if (window.addEventListener) {

From 96b0a0253fa4661378d687d71bf7ffb2a082622f Mon Sep 17 00:00:00 2001
From: Ben Newman <bn@cs.stanford.edu>
Date: Mon, 17 Jun 2013 13:54:30 -0400
Subject: [PATCH 11/94] Use grunt.util.spawn for jsx:* tasks instead of exec.

This should prevent "Warning: stdout maxBuffer exceeded" errors.

Also piping child process stdout and stderr to the parent process, so
you can see more of what's happening during the build process.
---
 grunt/tasks/jsx.js | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/grunt/tasks/jsx.js b/grunt/tasks/jsx.js
index 08a84ab4f0..7aa8407596 100644
--- a/grunt/tasks/jsx.js
+++ b/grunt/tasks/jsx.js
@@ -1,14 +1,14 @@
 'use strict';
 
-var exec = require("child_process").exec;
-var expand = require("grunt").file.expand;
+var grunt = require("grunt");
+var expand = grunt.file.expand;
+var spawn = grunt.util.spawn;
 
 module.exports = function() {
   var done = this.async();
   var config = this.data;
 
   var args = [
-    "bin/jsx",
     "--cache-dir", ".module-cache",
     "--relativize",
     config.sourceDir,
@@ -25,5 +25,18 @@ module.exports = function() {
   args.push.apply(args, rootIDs);
   args.push("--config", config.configFile);
 
-  exec(args.join(" "), done);
+  var child = spawn({
+    cmd: "bin/jsx",
+    args: args
+  }, function(error, result, code) {
+    if (error) {
+      grunt.log.error(error);
+      done(false);
+    } else {
+      done();
+    }
+  });
+
+  child.stdout.pipe(process.stdout);
+  child.stderr.pipe(process.stderr);
 };

From 8592eacbf9c94e48c0133c2124414f5910ba42b9 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 14 Jun 2013 16:22:39 -0700
Subject: [PATCH 12/94] Use Node Cache in ReactComponent

There are currently two places where we lookup and cache nodes: `ReactDOMNodeCache` and `ReactComponent`. Instead, we should just consolidate caches and make `ReactComponent` use `ReactDOMNodeCache`.
---
 src/core/ReactComponent.js                    | 19 +-----
 src/core/ReactDOMIDOperations.js              | 16 ++---
 src/core/ReactDOMNodeCache.js                 | 66 ++++++++++++++-----
 .../__tests__/ReactDOMIDOperations-test.js    |  8 +--
 4 files changed, 66 insertions(+), 43 deletions(-)

diff --git a/src/core/ReactComponent.js b/src/core/ReactComponent.js
index b9aa2330c4..f7ff79b245 100644
--- a/src/core/ReactComponent.js
+++ b/src/core/ReactComponent.js
@@ -18,9 +18,9 @@
 
 "use strict";
 
-var ExecutionEnvironment = require('ExecutionEnvironment');
 var ReactCurrentOwner = require('ReactCurrentOwner');
 var ReactDOMIDOperations = require('ReactDOMIDOperations');
+var ReactDOMNodeCache = require('ReactDOMNodeCache');
 var ReactMount = require('ReactMount');
 var ReactOwner = require('ReactOwner');
 var ReactReconcileTransaction = require('ReactReconcileTransaction');
@@ -207,24 +207,11 @@ var ReactComponent = {
      * @protected
      */
     getDOMNode: function() {
-      invariant(
-        ExecutionEnvironment.canUseDOM,
-        'getDOMNode(): The DOM is not supported in the current environment.'
-      );
       invariant(
         this.isMounted(),
         'getDOMNode(): A component must be mounted to have a DOM node.'
       );
-      var rootNode = this._rootNode;
-      if (!rootNode) {
-        rootNode = document.getElementById(this._rootNodeID);
-        if (!rootNode) {
-          // TODO: Log the frequency that we reach this path.
-          rootNode = ReactMount.findReactRenderedDOMNodeSlow(this._rootNodeID);
-        }
-        this._rootNode = rootNode;
-      }
-      return rootNode;
+      return ReactDOMNodeCache.getNodeByID(this._rootNodeID);
     },
 
     /**
@@ -372,7 +359,7 @@ var ReactComponent = {
       if (props.ref != null) {
         ReactOwner.removeComponentAsRefFrom(this, props.ref, props[OWNER]);
       }
-      this._rootNode = null;
+      ReactDOMNodeCache.purgeID(this._rootNodeID);
       this._rootNodeID = null;
       this._lifeCycleState = ComponentLifeCycle.UNMOUNTED;
     },
diff --git a/src/core/ReactDOMIDOperations.js b/src/core/ReactDOMIDOperations.js
index b51ffbd019..531de5338a 100644
--- a/src/core/ReactDOMIDOperations.js
+++ b/src/core/ReactDOMIDOperations.js
@@ -66,7 +66,7 @@ var ReactDOMIDOperations = {
    * @internal
    */
   updatePropertyByID: function(id, name, value) {
-    var node = ReactDOMNodeCache.getCachedNodeByID(id);
+    var node = ReactDOMNodeCache.getNodeByID(id);
     invariant(
       !INVALID_PROPERTY_ERRORS.hasOwnProperty(name),
       'updatePropertyByID(...): %s',
@@ -84,7 +84,7 @@ var ReactDOMIDOperations = {
    * @internal
    */
   deletePropertyByID: function(id, name, value) {
-    var node = ReactDOMNodeCache.getCachedNodeByID(id);
+    var node = ReactDOMNodeCache.getNodeByID(id);
     invariant(
       !INVALID_PROPERTY_ERRORS.hasOwnProperty(name),
       'updatePropertyByID(...): %s',
@@ -121,7 +121,7 @@ var ReactDOMIDOperations = {
    * @internal
    */
   updateStylesByID: function(id, styles) {
-    var node = ReactDOMNodeCache.getCachedNodeByID(id);
+    var node = ReactDOMNodeCache.getNodeByID(id);
     CSSPropertyOperations.setValueForStyles(node, styles);
   },
 
@@ -133,7 +133,7 @@ var ReactDOMIDOperations = {
    * @internal
    */
   updateInnerHTMLByID: function(id, html) {
-    var node = ReactDOMNodeCache.getCachedNodeByID(id);
+    var node = ReactDOMNodeCache.getNodeByID(id);
     // HACK: IE8- normalize whitespace in innerHTML, removing leading spaces.
     // @see quirksmode.org/bugreports/archives/2004/11/innerhtml_and_t.html
     node.innerHTML = (html && html.__html || '').replace(/^ /g, '&nbsp;');
@@ -147,7 +147,7 @@ var ReactDOMIDOperations = {
    * @internal
    */
   updateTextContentByID: function(id, content) {
-    var node = ReactDOMNodeCache.getCachedNodeByID(id);
+    var node = ReactDOMNodeCache.getNodeByID(id);
     node[textContentAccessor] = content;
   },
 
@@ -160,7 +160,7 @@ var ReactDOMIDOperations = {
    * @see {Danger.dangerouslyReplaceNodeWithMarkup}
    */
   dangerouslyReplaceNodeWithMarkupByID: function(id, markup) {
-    var node = ReactDOMNodeCache.getCachedNodeByID(id);
+    var node = ReactDOMNodeCache.getNodeByID(id);
     DOMChildrenOperations.dangerouslyReplaceNodeWithMarkup(node, markup);
     ReactDOMNodeCache.purgeEntireCache();
   },
@@ -170,13 +170,13 @@ var ReactDOMIDOperations = {
    *       Detect if any elements were removed instead of blindly purging.
    */
   manageChildrenByParentID: function(parentID, domOperations) {
-    var parent = ReactDOMNodeCache.getCachedNodeByID(parentID);
+    var parent = ReactDOMNodeCache.getNodeByID(parentID);
     DOMChildrenOperations.manageChildren(parent, domOperations);
     ReactDOMNodeCache.purgeEntireCache();
   },
 
   setTextNodeValueAtIndexByParentID: function(parentID, index, value) {
-    var parent = ReactDOMNodeCache.getCachedNodeByID(parentID);
+    var parent = ReactDOMNodeCache.getNodeByID(parentID);
     DOMChildrenOperations.setTextNodeValueAtIndex(parent, index, value);
   }
 
diff --git a/src/core/ReactDOMNodeCache.js b/src/core/ReactDOMNodeCache.js
index 385ad5a27d..eaec6501ba 100644
--- a/src/core/ReactDOMNodeCache.js
+++ b/src/core/ReactDOMNodeCache.js
@@ -14,39 +14,75 @@
  * limitations under the License.
  *
  * @providesModule ReactDOMNodeCache
+ * @typechecks
  */
 
 "use strict";
 
+var ExecutionEnvironment = require('ExecutionEnvironment');
 var ReactMount = require('ReactMount');
 
+var invariant = require('invariant');
+
 var nodeCache = {};
 
 /**
  * DOM node cache only intended for use by React. Placed into a shared module so
  * that both read and write utilities may benefit from a shared cache.
+ *
+ * @internal
  */
 var ReactDOMNodeCache = {
+
   /**
-   * Releases fast id lookups (node/style cache). This implementation is
-   * aggressive with purging because the bookkeeping associated with doing fine
-   * grained deleted from the cache may outweight the benefits of the cache. The
-   * heuristic that should be used to purge is 'any time anything is deleted'.
-   * Typically this means that a large amount of content is being replaced and
-   * several elements would need purging regardless. It's also a time when an
-   * application is likely not in the middle of a "smooth operation" (such as
-   * animating/scrolling).
+   * Finds the node with the supplied React-generated DOM ID.
+   *
+   * @param {string} id A React-generated DOM ID.
+   * @return {?DOMElement} DOM node with the suppled `id`.
+   * @internal
+   */
+  getNodeByID: function(id) {
+    invariant(
+      ExecutionEnvironment.canUseDOM,
+      'getDOMNode(): The DOM is not supported in the current environment.'
+    );
+    if (!nodeCache[id]) {
+      nodeCache[id] =
+        document.getElementById(id) ||
+        ReactMount.findReactRenderedDOMNodeSlow(id);
+    }
+    return nodeCache[id];
+  },
+
+  /**
+   * Purges the supplied ID from cache.
+   *
+   * @param {string} id A React-generated DOM ID.
+   * @internal
+   */
+  purgeID: function(id) {
+    nodeCache[id] = null;
+  },
+
+  /**
+   * Purges the entire node cache used for fast ID lookups.
+   *
+   * This implementation is aggressive with purging because the bookkeeping
+   * associated with doing fine-grained deletes from the cache may outweight the
+   * benefits of the cache.
+   *
+   * The heuristic used to purge is 'any time anything is deleted'. Typically
+   * this means that a large amount of content is being replaced and several
+   * elements would need purging regardless. This is also when applications are
+   * less likely to be in the middle of "smooth operations" such as animations
+   * or scrolling.
+   *
+   * @internal
    */
   purgeEntireCache: function() {
     nodeCache = {};
-    return nodeCache;
-  },
-  getCachedNodeByID: function(id) {
-    return nodeCache[id] ||
-      (nodeCache[id] =
-        document.getElementById(id) ||
-        ReactMount.findReactRenderedDOMNodeSlow(id));
   }
+
 };
 
 module.exports = ReactDOMNodeCache;
diff --git a/src/core/__tests__/ReactDOMIDOperations-test.js b/src/core/__tests__/ReactDOMIDOperations-test.js
index c4d4bc8ca0..aa717aafd0 100644
--- a/src/core/__tests__/ReactDOMIDOperations-test.js
+++ b/src/core/__tests__/ReactDOMIDOperations-test.js
@@ -27,7 +27,7 @@ describe('ReactDOMIDOperations', function() {
   var keyOf = require('keyOf');
 
   it('should disallow updating special properties', function() {
-    spyOn(ReactDOMNodeCache, "getCachedNodeByID");
+    spyOn(ReactDOMNodeCache, "getNodeByID");
     spyOn(DOMPropertyOperations, "setValueForProperty");
 
     expect(function() {
@@ -39,7 +39,7 @@ describe('ReactDOMIDOperations', function() {
     }).toThrow();
 
     expect(
-      ReactDOMNodeCache.getCachedNodeByID.argsForCall[0][0]
+      ReactDOMNodeCache.getNodeByID.argsForCall[0][0]
     ).toBe('testID');
 
     expect(
@@ -49,7 +49,7 @@ describe('ReactDOMIDOperations', function() {
 
   it('should update innerHTML and special-case whitespace', function() {
     var stubNode = document.createElement('div');
-    spyOn(ReactDOMNodeCache, "getCachedNodeByID").andReturn(stubNode);
+    spyOn(ReactDOMNodeCache, "getNodeByID").andReturn(stubNode);
 
     ReactDOMIDOperations.updateInnerHTMLByID(
       'testID',
@@ -57,7 +57,7 @@ describe('ReactDOMIDOperations', function() {
     );
 
     expect(
-      ReactDOMNodeCache.getCachedNodeByID.argsForCall[0][0]
+      ReactDOMNodeCache.getNodeByID.argsForCall[0][0]
     ).toBe('testID');
 
     expect(stubNode.innerHTML).toBe('&nbsp;testContent');

From c1576fcf9744882fa59c2876fb4fd44720140307 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Paul=20O=E2=80=99Shannessy?= <paul@oshannessy.com>
Date: Fri, 14 Jun 2013 16:43:10 -0700
Subject: [PATCH 13/94] Remove trailing whitespace

---
 src/core/React.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/React.js b/src/core/React.js
index 1a9e61fbb8..7bdb3b39bd 100644
--- a/src/core/React.js
+++ b/src/core/React.js
@@ -31,7 +31,7 @@ ReactDefaultInjection.inject();
 
 var React = {
   DOM: ReactDOM,
-  Props: ReactProps,  
+  Props: ReactProps,
   initializeTouchEvents: function(shouldUseTouch) {
     ReactMount.useTouchEvents = shouldUseTouch;
   },

From 1112f1a00305626377f0f9402f139622c57be014 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 14 Jun 2013 16:45:03 -0700
Subject: [PATCH 14/94] React onlyChild utility.

Small utility that extracts and validates that there is only a single
child passed to a React composite component. The benefit here is that we
abstract away *how* the children are actually stored while we iterate on
different approaches. This way we won't break callsites as we try different
ideas. When we settle on a final approach, all of these callsites will still
work.
---
 src/utils/__tests__/onlyChild-test.js | 89 +++++++++++++++++++++++++++
 src/utils/onlyChild.js                | 33 ++++++++++
 2 files changed, 122 insertions(+)
 create mode 100644 src/utils/__tests__/onlyChild-test.js
 create mode 100644 src/utils/onlyChild.js

diff --git a/src/utils/__tests__/onlyChild-test.js b/src/utils/__tests__/onlyChild-test.js
new file mode 100644
index 0000000000..9c0c51febc
--- /dev/null
+++ b/src/utils/__tests__/onlyChild-test.js
@@ -0,0 +1,89 @@
+/**
+ * @emails react-core
+ * @jsx React.DOM
+ */
+
+"use strict";
+
+describe('onlyChild', function() {
+
+  var React;
+  var onlyChild;
+  var WrapComponent;
+
+  beforeEach(function() {
+    React = require('React');
+    onlyChild = require('onlyChild');
+    WrapComponent = React.createClass({
+      render: function() {
+        return (
+          <div>
+            {onlyChild(this.props.children, this.props.mapFn, this)}
+          </div>
+        );
+      }
+    });
+  });
+
+  it('should fail when passed two children', function() {
+    expect(function() {
+      var instance =
+        <WrapComponent>
+          <div />
+          <span />
+        </WrapComponent>;
+      onlyChild(instance.props.children);
+    }).toThrow();
+  });
+
+  it('should fail when passed nully values', function() {
+    expect(function() {
+      var instance =
+        <WrapComponent>
+          {null}
+        </WrapComponent>;
+      onlyChild(instance.props.children);
+    }).toThrow();
+
+    expect(function() {
+      var instance =
+        <WrapComponent>
+          {undefined}
+        </WrapComponent>;
+      onlyChild(instance.props.children);
+    }).toThrow();
+  });
+
+  it('should fail when key/value objects', function() {
+    expect(function() {
+      var instance =
+        <WrapComponent>
+          {{oneThing: <span />}}
+        </WrapComponent>;
+      onlyChild(instance.props.children);
+    }).toThrow();
+  });
+
+
+  it('should not fail when passed interpolated single child', function() {
+    expect(function() {
+      var instance =
+        <WrapComponent>
+          {<span />}
+        </WrapComponent>;
+      onlyChild(instance.props.children);
+    }).not.toThrow();
+  });
+
+
+  it('should return the only child', function() {
+    expect(function() {
+      var instance =
+        <WrapComponent>
+          <span />
+        </WrapComponent>;
+      onlyChild(instance.props.children);
+    }).not.toThrow();
+  });
+
+});
diff --git a/src/utils/onlyChild.js b/src/utils/onlyChild.js
new file mode 100644
index 0000000000..9e4f36e223
--- /dev/null
+++ b/src/utils/onlyChild.js
@@ -0,0 +1,33 @@
+/**
+ * @providesModule onlyChild
+ */
+"use strict";
+
+var ReactComponent = require('ReactComponent');
+
+var invariant = require('invariant');
+
+/**
+ * Returns the first child in a collection of children and verifies that there
+ * is only one child in the collection. The current implementation of this
+ * function assumes that children have been flattened, but the purpose of this
+ * helper function is to abstract away the particular structure of children.
+ *
+ * @param {?object} children Child collection structure.
+ * @return {ReactComponent} The first and only `ReactComponent` contained in the
+ * structure.
+ */
+function onlyChild(children) {
+  invariant(Array.isArray(children), 'onlyChild must be passed a valid Array.');
+  invariant(
+    children.length === 1,
+    'onlyChild must be passed an Array with exactly one child.'
+  );
+  invariant(
+    ReactComponent.isValidComponent(children[0]),
+    'onlyChild must be passed an Array with exactly one child.'
+  );
+  return children[0];
+}
+
+module.exports = onlyChild;

From 03464dc148374c1883d02c6aae150fc93ffd85de Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 14 Jun 2013 16:45:07 -0700
Subject: [PATCH 15/94] Fix `EventPluginRegistry` Unit Tests in GitHub

Dumping the mock cache isn't dirying the modules in the open source version, so we have to unit test a different way. If we can fix the unit test framework, we should revert this.

Also, I added strict mode to `EventPluginRegistry.js`.

See: https://github.com/facebook/react/pull/91
---
 src/event/EventPluginRegistry.js                | 14 ++++++++++++++
 src/event/__tests__/EventPluginRegistry-test.js | 14 ++++++++++++++
 2 files changed, 28 insertions(+)

diff --git a/src/event/EventPluginRegistry.js b/src/event/EventPluginRegistry.js
index f36ca3c3a6..74ba7062b2 100644
--- a/src/event/EventPluginRegistry.js
+++ b/src/event/EventPluginRegistry.js
@@ -1,4 +1,18 @@
 /**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
  * @providesModule EventPluginRegistry
  * @typechecks
  */
diff --git a/src/event/__tests__/EventPluginRegistry-test.js b/src/event/__tests__/EventPluginRegistry-test.js
index c8755c8b38..c22d598cc7 100644
--- a/src/event/__tests__/EventPluginRegistry-test.js
+++ b/src/event/__tests__/EventPluginRegistry-test.js
@@ -1,4 +1,18 @@
 /**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
  * @emails react-core
  */
 

From 88e90d5601aa29e606ed2c2e248f34df46ecad6f Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 14 Jun 2013 16:45:14 -0700
Subject: [PATCH 16/94] Use Synthetic Events

Swaps out usage of `AbstractEvent` with `SyntheticEvent` (and subclasses).
---
 ...vent-test.js => ReactEventEmitter-test.js} |   4 +-
 src/event/AbstractEvent.js                    | 253 ---------
 src/event/EventPluginHub.js                   |   2 +-
 src/event/EventPluginRegistry.js              |   4 +-
 src/event/EventPluginUtils.js                 | 107 ++--
 src/event/EventPropagators.js                 |  56 +-
 .../__tests__/EventPluginRegistry-test.js     |  16 +-
 .../AnalyticsEventPluginFactory.js            |   6 +-
 src/eventPlugins/EnterLeaveEventPlugin.js     | 137 +++--
 src/eventPlugins/ResponderEventPlugin.js      | 287 +++++-----
 src/eventPlugins/SimpleEventPlugin.js         | 501 +++++++++---------
 src/eventPlugins/TapEventPlugin.js            | 114 ++--
 src/eventPlugins/TextChangeEventPlugin.js     | 119 ++---
 .../__tests__/ResponderEventPlugin-test.js    |  52 +-
 src/test/ReactTestUtils.js                    |   6 +-
 15 files changed, 714 insertions(+), 950 deletions(-)
 rename src/core/__tests__/{ReactEvent-test.js => ReactEventEmitter-test.js} (98%)
 delete mode 100644 src/event/AbstractEvent.js

diff --git a/src/core/__tests__/ReactEvent-test.js b/src/core/__tests__/ReactEventEmitter-test.js
similarity index 98%
rename from src/core/__tests__/ReactEvent-test.js
rename to src/core/__tests__/ReactEventEmitter-test.js
index 9fb5fe9eb6..c2646d3332 100644
--- a/src/core/__tests__/ReactEvent-test.js
+++ b/src/core/__tests__/ReactEventEmitter-test.js
@@ -229,7 +229,7 @@ describe('ReactEventEmitter', function() {
 
   it('should invoke handlers that were removed while bubbling', function() {
     var handleParentClick = mocks.getMockFunction();
-    var handleChildClick = function(abstractEvent) {
+    var handleChildClick = function(event) {
       ReactEventEmitter.deleteAllListeners(PARENT.id);
     };
     ReactEventEmitter.putListener(CHILD.id, ON_CLICK_KEY, handleChildClick);
@@ -240,7 +240,7 @@ describe('ReactEventEmitter', function() {
 
   it('should not invoke newly inserted handlers while bubbling', function() {
     var handleParentClick = mocks.getMockFunction();
-    var handleChildClick = function(abstractEvent) {
+    var handleChildClick = function(event) {
       ReactEventEmitter.putListener(PARENT.id, ON_CLICK_KEY, handleParentClick);
     };
     ReactEventEmitter.putListener(CHILD.id, ON_CLICK_KEY, handleChildClick);
diff --git a/src/event/AbstractEvent.js b/src/event/AbstractEvent.js
deleted file mode 100644
index ad14378a69..0000000000
--- a/src/event/AbstractEvent.js
+++ /dev/null
@@ -1,253 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule AbstractEvent
- */
-
-"use strict";
-
-var BrowserEnv = require('BrowserEnv');
-var PooledClass = require('PooledClass');
-var TouchEventUtils = require('TouchEventUtils');
-
-var emptyFunction = require('emptyFunction');
-
-var MAX_POOL_SIZE = 20;
-
-/**
- * AbstractEvent copy constructor. @see `PooledClass`. Provides a single place
- * to define all cross browser normalization of DOM events. Does not attempt to
- * extend a native event, rather creates a completely new object that has a
- * reference to the nativeEvent through .nativeEvent member. The property .data
- * should hold all data that is extracted from the event in a cross browser
- * manner. Application code should use the data field when possible, not the
- * unreliable native event.
- */
-function AbstractEvent(
-    reactEventType,
-    reactTargetID, // Allows the abstract target to differ from native.
-    nativeEvent,
-    data) {
-  this.reactEventType = reactEventType;
-  this.reactTargetID = reactTargetID || '';
-  this.nativeEvent = nativeEvent;
-  this.data = data;
-  // TODO: Deprecate storing target - doesn't always make sense for some types
-  this.target = nativeEvent && nativeEvent.target;
-
-  /**
-   * As a performance optimization, we tag the existing event with the listeners
-   * (or listener [singular] if only one). This avoids having to package up an
-   * abstract event along with the set of listeners into a wrapping "dispatch"
-   * object. No one should ever read this property except event system and
-   * plugin/dispatcher code. We also tag the abstract event with a parallel
-   * ID array. _dispatchListeners[i] is being dispatched to a DOM node at ID
-   * _dispatchIDs[i]. The lengths should never, ever, ever be different.
-   */
-  this._dispatchListeners = null;
-  this._dispatchIDs = null;
-
-  this.isPropagationStopped = false;
-  this.isPersistent = emptyFunction.thatReturnsFalse;
-}
-
-/** `PooledClass` looks for this. */
-AbstractEvent.poolSize = MAX_POOL_SIZE;
-
-/**
- * `PooledClass` looks for `destructor` on each instance it releases. We need to
- * ensure that we remove all references to listeners which could trap large
- * amounts of memory in their closures.
- */
-AbstractEvent.prototype.destructor = function() {
-  this.target = null;
-  this._dispatchListeners = null;
-  this._dispatchIDs = null;
-};
-
-/**
- * Enhance the `AbstractEvent` class to have pooling abilities. We instruct
- * `PooledClass` that our copy constructor accepts five arguments (this is just
- * a performance optimization). These objects are instantiated frequently.
- */
-PooledClass.addPoolingTo(AbstractEvent, PooledClass.fiveArgumentPooler);
-
-AbstractEvent.prototype.stopPropagation = function() {
-  this.isPropagationStopped = true;
-  if (this.nativeEvent.stopPropagation) {
-    this.nativeEvent.stopPropagation();
-  }
-  // IE8 only understands cancelBubble, not stopPropagation().
-  this.nativeEvent.cancelBubble = true;
-};
-
-AbstractEvent.prototype.preventDefault = function() {
-  AbstractEvent.preventDefaultOnNativeEvent(this.nativeEvent);
-};
-
-/**
- * We clear out all dispatched `AbstractEvent`s after each event loop, adding
- * them back into the pool. This allows a way to hold onto a reference that
- * won't be added back into the pool.
- */
-AbstractEvent.prototype.persist = function() {
-  this.isPersistent = emptyFunction.thatReturnsTrue;
-};
-
-/**
- * Utility function for preventing default in cross browser manner.
- */
-AbstractEvent.preventDefaultOnNativeEvent = function(nativeEvent) {
-  if (nativeEvent.preventDefault) {
-    nativeEvent.preventDefault();
-  } else {
-    nativeEvent.returnValue = false;
-  }
-};
-
-/**
- * @param {Element} target The target element.
- */
-AbstractEvent.normalizeScrollDataFromTarget = function(target) {
-  return {
-    scrollTop: target.scrollTop,
-    scrollLeft: target.scrollLeft,
-    clientWidth: target.clientWidth,
-    clientHeight: target.clientHeight,
-    scrollHeight: target.scrollHeight,
-    scrollWidth: target.scrollWidth
-  };
-};
-
-/*
- * There are some normalizations that need to happen for various browsers. In
- * addition to replacing the general event fixing with a framework such as
- * jquery, we need to normalize mouse events here. Code below is mostly borrowed
- * from: jScrollPane/script/jquery.mousewheel.js
- */
-AbstractEvent.normalizeMouseWheelData = function(nativeEvent) {
-  var delta = 0;
-  var deltaX = 0;
-  var deltaY = 0;
-
-  /* traditional scroll wheel data */
-  if ( nativeEvent.wheelDelta ) { delta = nativeEvent.wheelDelta/120; }
-  if ( nativeEvent.detail     ) { delta = -nativeEvent.detail/3; }
-
-  /* Multidimensional scroll (touchpads) with deltas */
-  deltaY = delta;
-
-  /* Gecko based browsers */
-  if (nativeEvent.axis !== undefined &&
-      nativeEvent.axis === nativeEvent.HORIZONTAL_AXIS ) {
-    deltaY = 0;
-    deltaX = -delta;
-  }
-
-  /* Webkit based browsers */
-  if (nativeEvent.wheelDeltaY !== undefined ) {
-    deltaY = nativeEvent.wheelDeltaY/120;
-  }
-  if (nativeEvent.wheelDeltaX !== undefined ) {
-    deltaX = -nativeEvent.wheelDeltaX/120;
-  }
-
-  return { delta: delta, deltaX: deltaX, deltaY: deltaY };
-};
-
-/**
- * I <3 Quirksmode.org:
- * http://www.quirksmode.org/js/events_properties.html
- */
-AbstractEvent.isNativeClickEventRightClick = function(nativeEvent) {
-  return nativeEvent.which ? nativeEvent.which === 3 :
-    nativeEvent.button ? nativeEvent.button === 2 :
-    false;
-};
-
-AbstractEvent.normalizePointerData = function(nativeEvent) {
-  return {
-    globalX: AbstractEvent.eventPageX(nativeEvent),
-    globalY: AbstractEvent.eventPageY(nativeEvent),
-    rightMouseButton:
-      AbstractEvent.isNativeClickEventRightClick(nativeEvent)
-  };
-};
-
-AbstractEvent.normalizeDragEventData =
-  function(nativeEvent, globalX, globalY, startX, startY) {
-    return {
-      globalX: globalX,
-      globalY: globalY,
-      startX: startX,
-      startY: startY
-    };
-  };
-
-/**
- * Warning: It is possible to move your finger on a touch surface, yet not
- * effect the `eventPageX/Y` because the touch had caused a scroll that
- * compensated for your movement. To track movements across the page, prevent
- * default to avoid scrolling, and control scrolling in javascript.
- */
-
-/**
- * Gets the exact position of a touch/mouse event on the page with respect to
- * the document body. The only reason why this method is needed instead of using
- * `TouchEventUtils.extractSingleTouch` is to support IE8-. Mouse events in all
- * browsers except IE8- contain a pageY. IE8 and below require clientY
- * computation:
- *
- * @param {Event} nativeEvent Native event, possibly touch or mouse.
- * @return {number} Coordinate with respect to document body.
- */
-AbstractEvent.eventPageY = function(nativeEvent) {
-  var singleTouch = TouchEventUtils.extractSingleTouch(nativeEvent);
-  if (singleTouch) {
-    return singleTouch.pageY;
-  } else if (typeof nativeEvent.pageY !== 'undefined') {
-    return nativeEvent.pageY;
-  } else {
-    return nativeEvent.clientY + BrowserEnv.currentPageScrollTop;
-  }
-};
-
-/**
- * @see `AbstractEvent.eventPageY`.
- *
- * @param {Event} nativeEvent Native event, possibly touch or mouse.
- * @return {number} Coordinate with respect to document body.
- */
-AbstractEvent.eventPageX = function(nativeEvent) {
-  var singleTouch = TouchEventUtils.extractSingleTouch(nativeEvent);
-  if (singleTouch) {
-    return singleTouch.pageX;
-  } else if (typeof nativeEvent.pageX !== 'undefined') {
-    return nativeEvent.pageX;
-  } else {
-    return nativeEvent.clientX + BrowserEnv.currentPageScrollLeft;
-  }
-};
-
-/**
- * @deprecated
- */
-AbstractEvent.persistentCloneOf = function(abstractEvent) {
-  abstractEvent.persist();
-  return abstractEvent;
-};
-
-module.exports = AbstractEvent;
-
diff --git a/src/event/EventPluginHub.js b/src/event/EventPluginHub.js
index 03133e4906..ff0be9d8a1 100644
--- a/src/event/EventPluginHub.js
+++ b/src/event/EventPluginHub.js
@@ -65,7 +65,7 @@ var executeDispatchesAndRelease = function(event) {
  *     Required. When a top-level event is fired, this method is expected to
  *     extract synthetic events that will in turn be queued and dispatched.
  *
- *   `abstractEventTypes` {object}
+ *   `eventTypes` {object}
  *     Optional, plugins that fire events must publish a mapping of registration
  *     names that are used to register listeners. Values of this mapping must
  *     be objects that contain `registrationName` or `phasedRegistrationNames`.
diff --git a/src/event/EventPluginRegistry.js b/src/event/EventPluginRegistry.js
index 74ba7062b2..e9302eb495 100644
--- a/src/event/EventPluginRegistry.js
+++ b/src/event/EventPluginRegistry.js
@@ -60,7 +60,7 @@ function recomputePluginOrdering() {
       pluginName
     );
     EventPluginRegistry.plugins[pluginIndex] = PluginModule;
-    var publishedEvents = PluginModule.abstractEventTypes;
+    var publishedEvents = PluginModule.eventTypes;
     for (var eventName in publishedEvents) {
       invariant(
         publishEventForPlugin(publishedEvents[eventName], PluginModule),
@@ -198,7 +198,7 @@ var EventPluginRegistry = {
    * @internal
    */
   getPluginModuleForEvent: function(event) {
-    var dispatchConfig = event.reactEventType;
+    var dispatchConfig = event.dispatchConfig;
     if (dispatchConfig.registrationName) {
       return EventPluginRegistry.registrationNames[
         dispatchConfig.registrationName
diff --git a/src/event/EventPluginUtils.js b/src/event/EventPluginUtils.js
index 219090e77a..686f7073eb 100644
--- a/src/event/EventPluginUtils.js
+++ b/src/event/EventPluginUtils.js
@@ -19,7 +19,6 @@
 "use strict";
 
 var EventConstants = require('EventConstants');
-var AbstractEvent = require('AbstractEvent');
 
 var invariant = require('invariant');
 
@@ -40,27 +39,11 @@ function isStartish(topLevelType) {
          topLevelType === topLevelTypes.topTouchStart;
 }
 
-function storePageCoordsIn(obj, nativeEvent) {
-  var pageX = AbstractEvent.eventPageX(nativeEvent);
-  var pageY = AbstractEvent.eventPageY(nativeEvent);
-  obj.pageX = pageX;
-  obj.pageY = pageY;
-}
-
-function eventDistance(coords, nativeEvent) {
-  var pageX = AbstractEvent.eventPageX(nativeEvent);
-  var pageY = AbstractEvent.eventPageY(nativeEvent);
-  return Math.pow(
-    Math.pow(pageX - coords.pageX, 2) + Math.pow(pageY - coords.pageY, 2),
-    0.5
-  );
-}
-
 var validateEventDispatches;
 if (__DEV__) {
-  validateEventDispatches = function(abstractEvent) {
-    var dispatchListeners = abstractEvent._dispatchListeners;
-    var dispatchIDs = abstractEvent._dispatchIDs;
+  validateEventDispatches = function(event) {
+    var dispatchListeners = event._dispatchListeners;
+    var dispatchIDs = event._dispatchIDs;
 
     var listenersIsArr = Array.isArray(dispatchListeners);
     var idsIsArr = Array.isArray(dispatchIDs);
@@ -71,53 +54,52 @@ if (__DEV__) {
 
     invariant(
       idsIsArr === listenersIsArr && IDsLen === listenersLen,
-      'EventPluginUtils: Invalid `abstractEvent`.'
+      'EventPluginUtils: Invalid `event`.'
     );
   };
 }
 
 /**
- * Invokes `cb(abstractEvent, listener, id)`. Avoids using call if no scope is
+ * Invokes `cb(event, listener, id)`. Avoids using call if no scope is
  * provided. The `(listener,id)` pair effectively forms the "dispatch" but are
  * kept separate to conserve memory.
  */
-function forEachEventDispatch(abstractEvent, cb) {
-  var dispatchListeners = abstractEvent._dispatchListeners;
-  var dispatchIDs = abstractEvent._dispatchIDs;
+function forEachEventDispatch(event, cb) {
+  var dispatchListeners = event._dispatchListeners;
+  var dispatchIDs = event._dispatchIDs;
   if (__DEV__) {
-    validateEventDispatches(abstractEvent);
+    validateEventDispatches(event);
   }
   if (Array.isArray(dispatchListeners)) {
-    var i;
-    for (
-      i = 0;
-      i < dispatchListeners.length && !abstractEvent.isPropagationStopped;
-      i++) {
+    for (var i = 0; i < dispatchListeners.length; i++) {
+      if (event.isPropagationStopped()) {
+        break;
+      }
       // Listeners and IDs are two parallel arrays that are always in sync.
-      cb(abstractEvent, dispatchListeners[i], dispatchIDs[i]);
+      cb(event, dispatchListeners[i], dispatchIDs[i]);
     }
   } else if (dispatchListeners) {
-    cb(abstractEvent, dispatchListeners, dispatchIDs);
+    cb(event, dispatchListeners, dispatchIDs);
   }
 }
 
 /**
  * Default implementation of PluginModule.executeDispatch().
- * @param {AbstractEvent} AbstractEvent to handle
+ * @param {SyntheticEvent} SyntheticEvent to handle
  * @param {function} Application-level callback
  * @param {string} domID DOM id to pass to the callback.
  */
-function executeDispatch(abstractEvent, listener, domID) {
-  listener(abstractEvent, domID);
+function executeDispatch(event, listener, domID) {
+  listener(event, domID);
 }
 
 /**
  * Standard/simple iteration through an event's collected dispatches.
  */
-function executeDispatchesInOrder(abstractEvent, executeDispatch) {
-  forEachEventDispatch(abstractEvent, executeDispatch);
-  abstractEvent._dispatchListeners = null;
-  abstractEvent._dispatchIDs = null;
+function executeDispatchesInOrder(event, executeDispatch) {
+  forEachEventDispatch(event, executeDispatch);
+  event._dispatchListeners = null;
+  event._dispatchIDs = null;
 }
 
 /**
@@ -127,25 +109,24 @@ function executeDispatchesInOrder(abstractEvent, executeDispatch) {
  * @returns id of the first dispatch execution who's listener returns true, or
  * null if no listener returned true.
  */
-function executeDispatchesInOrderStopAtTrue(abstractEvent) {
-  var dispatchListeners = abstractEvent._dispatchListeners;
-  var dispatchIDs = abstractEvent._dispatchIDs;
+function executeDispatchesInOrderStopAtTrue(event) {
+  var dispatchListeners = event._dispatchListeners;
+  var dispatchIDs = event._dispatchIDs;
   if (__DEV__) {
-    validateEventDispatches(abstractEvent);
+    validateEventDispatches(event);
   }
   if (Array.isArray(dispatchListeners)) {
-    var i;
-    for (
-      i = 0;
-      i < dispatchListeners.length && !abstractEvent.isPropagationStopped;
-      i++) {
+    for (var i = 0; i < dispatchListeners.length; i++) {
+      if (event.isPropagationStopped()) {
+        break;
+      }
       // Listeners and IDs are two parallel arrays that are always in sync.
-      if (dispatchListeners[i](abstractEvent, dispatchIDs[i])) {
+      if (dispatchListeners[i](event, dispatchIDs[i])) {
         return dispatchIDs[i];
       }
     }
   } else if (dispatchListeners) {
-    if (dispatchListeners(abstractEvent, dispatchIDs)) {
+    if (dispatchListeners(event, dispatchIDs)) {
       return dispatchIDs;
     }
   }
@@ -161,30 +142,30 @@ function executeDispatchesInOrderStopAtTrue(abstractEvent) {
  *
  * @returns The return value of executing the single dispatch.
  */
-function executeDirectDispatch(abstractEvent) {
+function executeDirectDispatch(event) {
   if (__DEV__) {
-    validateEventDispatches(abstractEvent);
+    validateEventDispatches(event);
   }
-  var dispatchListener = abstractEvent._dispatchListeners;
-  var dispatchID = abstractEvent._dispatchIDs;
+  var dispatchListener = event._dispatchListeners;
+  var dispatchID = event._dispatchIDs;
   invariant(
     !Array.isArray(dispatchListener),
-    'executeDirectDispatch(...): Invalid `abstractEvent`.'
+    'executeDirectDispatch(...): Invalid `event`.'
   );
   var res = dispatchListener ?
-    dispatchListener(abstractEvent, dispatchID) :
+    dispatchListener(event, dispatchID) :
     null;
-  abstractEvent._dispatchListeners = null;
-  abstractEvent._dispatchIDs = null;
+  event._dispatchListeners = null;
+  event._dispatchIDs = null;
   return res;
 }
 
 /**
- * @param {AbstractEvent} abstractEvent
+ * @param {SyntheticEvent} event
  * @returns {bool} True iff number of dispatches accumulated is greater than 0.
  */
-function hasDispatches(abstractEvent) {
-  return !!abstractEvent._dispatchListeners;
+function hasDispatches(event) {
+  return !!event._dispatchListeners;
 }
 
 /**
@@ -194,8 +175,6 @@ var EventPluginUtils = {
   isEndish: isEndish,
   isMoveish: isMoveish,
   isStartish: isStartish,
-  storePageCoordsIn: storePageCoordsIn,
-  eventDistance: eventDistance,
   executeDispatchesInOrder: executeDispatchesInOrder,
   executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
   executeDirectDispatch: executeDirectDispatch,
diff --git a/src/event/EventPropagators.js b/src/event/EventPropagators.js
index e7534f7a2d..26127b5d00 100644
--- a/src/event/EventPropagators.js
+++ b/src/event/EventPropagators.js
@@ -56,19 +56,19 @@ var injection = {
  * Some event types have a notion of different registration names for different
  * "phases" of propagation. This finds listeners by a given phase.
  */
-function listenerAtPhase(id, abstractEvent, propagationPhase) {
+function listenerAtPhase(id, event, propagationPhase) {
   var registrationName =
-    abstractEvent.reactEventType.phasedRegistrationNames[propagationPhase];
+    event.dispatchConfig.phasedRegistrationNames[propagationPhase];
   return getListener(id, registrationName);
 }
 
 /**
- * Tags an `AbstractEvent` with dispatched listeners. Creating this function
+ * Tags a `SyntheticEvent` with dispatched listeners. Creating this function
  * here, allows us to not have to bind or create functions for each event.
  * Mutating the event's members allows us to not have to create a wrapping
  * "dispatch" object that pairs the event with the listener.
  */
-function accumulateDirectionalDispatches(domID, upwards, abstractEvent) {
+function accumulateDirectionalDispatches(domID, upwards, event) {
   if (__DEV__) {
     if (!domID) {
       throw new Error('Dispatching id must not be null');
@@ -76,11 +76,10 @@ function accumulateDirectionalDispatches(domID, upwards, abstractEvent) {
     injection.validate();
   }
   var phase = upwards ? PropagationPhases.bubbled : PropagationPhases.captured;
-  var listener = listenerAtPhase(domID, abstractEvent, phase);
+  var listener = listenerAtPhase(domID, event, phase);
   if (listener) {
-    abstractEvent._dispatchListeners =
-      accumulate(abstractEvent._dispatchListeners, listener);
-    abstractEvent._dispatchIDs = accumulate(abstractEvent._dispatchIDs, domID);
+    event._dispatchListeners = accumulate(event._dispatchListeners, listener);
+    event._dispatchIDs = accumulate(event._dispatchIDs, domID);
   }
 }
 
@@ -91,12 +90,12 @@ function accumulateDirectionalDispatches(domID, upwards, abstractEvent) {
  * single traversal for the entire collection of events because each event may
  * have a different target.
  */
-function accumulateTwoPhaseDispatchesSingle(abstractEvent) {
-  if (abstractEvent && abstractEvent.reactEventType.phasedRegistrationNames) {
+function accumulateTwoPhaseDispatchesSingle(event) {
+  if (event && event.dispatchConfig.phasedRegistrationNames) {
     injection.InstanceHandle.traverseTwoPhase(
-      abstractEvent.reactTargetID,
+      event.dispatchMarker,
       accumulateDirectionalDispatches,
-      abstractEvent
+      event
     );
   }
 }
@@ -105,36 +104,35 @@ function accumulateTwoPhaseDispatchesSingle(abstractEvent) {
 /**
  * Accumulates without regard to direction, does not look for phased
  * registration names. Same as `accumulateDirectDispatchesSingle` but without
- * requiring that the `reactTargetID` be the same as the dispatched ID.
+ * requiring that the `dispatchMarker` be the same as the dispatched ID.
  */
-function accumulateDispatches(id, ignoredDirection, abstractEvent) {
-  if (abstractEvent && abstractEvent.reactEventType.registrationName) {
-    var registrationName = abstractEvent.reactEventType.registrationName;
+function accumulateDispatches(id, ignoredDirection, event) {
+  if (event && event.dispatchConfig.registrationName) {
+    var registrationName = event.dispatchConfig.registrationName;
     var listener = getListener(id, registrationName);
     if (listener) {
-      abstractEvent._dispatchListeners =
-        accumulate(abstractEvent._dispatchListeners, listener);
-      abstractEvent._dispatchIDs = accumulate(abstractEvent._dispatchIDs, id);
+      event._dispatchListeners = accumulate(event._dispatchListeners, listener);
+      event._dispatchIDs = accumulate(event._dispatchIDs, id);
     }
   }
 }
 
 /**
- * Accumulates dispatches on an `AbstractEvent`, but only for the
- * `reactTargetID`.
- * @param {AbstractEvent} abstractEvent
+ * Accumulates dispatches on an `SyntheticEvent`, but only for the
+ * `dispatchMarker`.
+ * @param {SyntheticEvent} event
  */
-function accumulateDirectDispatchesSingle(abstractEvent) {
-  if (abstractEvent && abstractEvent.reactEventType.registrationName) {
-    accumulateDispatches(abstractEvent.reactTargetID, null, abstractEvent);
+function accumulateDirectDispatchesSingle(event) {
+  if (event && event.dispatchConfig.registrationName) {
+    accumulateDispatches(event.dispatchMarker, null, event);
   }
 }
 
-function accumulateTwoPhaseDispatches(abstractEvents) {
+function accumulateTwoPhaseDispatches(events) {
   if (__DEV__) {
     injection.validate();
   }
-  forEachAccumulated(abstractEvents, accumulateTwoPhaseDispatchesSingle);
+  forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
 }
 
 function accumulateEnterLeaveDispatches(leave, enter, fromID, toID) {
@@ -151,11 +149,11 @@ function accumulateEnterLeaveDispatches(leave, enter, fromID, toID) {
 }
 
 
-function accumulateDirectDispatches(abstractEvents) {
+function accumulateDirectDispatches(events) {
   if (__DEV__) {
     injection.validate();
   }
-  forEachAccumulated(abstractEvents, accumulateDirectDispatchesSingle);
+  forEachAccumulated(events, accumulateDirectDispatchesSingle);
 }
 
 
diff --git a/src/event/__tests__/EventPluginRegistry-test.js b/src/event/__tests__/EventPluginRegistry-test.js
index c22d598cc7..f890a58169 100644
--- a/src/event/__tests__/EventPluginRegistry-test.js
+++ b/src/event/__tests__/EventPluginRegistry-test.js
@@ -155,13 +155,13 @@ describe('EventPluginRegistry', function() {
 
   it('should publish registration names of injected plugins', function() {
     var OnePlugin = createPlugin({
-      abstractEventTypes: {
+      eventTypes: {
         click: {registrationName: 'onClick'},
         focus: {registrationName: 'onFocus'}
       }
     });
     var TwoPlugin = createPlugin({
-      abstractEventTypes: {
+      eventTypes: {
         magic: {
           phasedRegistrationNames: {
             bubbled: 'onMagicBubble',
@@ -189,12 +189,12 @@ describe('EventPluginRegistry', function() {
 
   it('should throw if multiple registration names collide', function() {
     var OnePlugin = createPlugin({
-      abstractEventTypes: {
+      eventTypes: {
         photoCapture: {registrationName: 'onPhotoCapture'}
       }
     });
     var TwoPlugin = createPlugin({
-      abstractEventTypes: {
+      eventTypes: {
         photo: {
           phasedRegistrationNames: {
             bubbled: 'onPhotoBubble',
@@ -219,7 +219,7 @@ describe('EventPluginRegistry', function() {
 
   it('should throw if an invalid event is published', function() {
     var OnePlugin = createPlugin({
-      abstractEventTypes: {
+      eventTypes: {
         badEvent: {/* missing configuration */}
       }
     });
@@ -246,14 +246,14 @@ describe('EventPluginRegistry', function() {
     };
 
     var OnePlugin = createPlugin({
-      abstractEventTypes: {
+      eventTypes: {
         click: clickDispatchConfig,
         magic: magicDispatchConfig
       }
     });
 
-    var clickEvent = {reactEventType: clickDispatchConfig};
-    var magicEvent = {reactEventType: magicDispatchConfig};
+    var clickEvent = {dispatchConfig: clickDispatchConfig};
+    var magicEvent = {dispatchConfig: magicDispatchConfig};
 
     expect(EventPluginRegistry.getPluginModuleForEvent(clickEvent)).toBe(null);
     expect(EventPluginRegistry.getPluginModuleForEvent(magicEvent)).toBe(null);
diff --git a/src/eventPlugins/AnalyticsEventPluginFactory.js b/src/eventPlugins/AnalyticsEventPluginFactory.js
index f10a77804a..c2cf1e6ff5 100644
--- a/src/eventPlugins/AnalyticsEventPluginFactory.js
+++ b/src/eventPlugins/AnalyticsEventPluginFactory.js
@@ -133,14 +133,14 @@ if (__DEV__) {
 }
 
 /**
- * This plugin does not really extract any abstract events. Rather it just looks
- * at the top level event and bumps up counters as appropriate
+ * This plugin does not really extract any synthetic events. Rather it just
+ * looks at the top-level event and bumps up counters as appropriate
  *
  * @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 `AbstractEvent`s.
+ * @return {*} An accumulation of synthetic events.
  * @see {EventPluginHub.extractEvents}
  */
 function extractEvents(
diff --git a/src/eventPlugins/EnterLeaveEventPlugin.js b/src/eventPlugins/EnterLeaveEventPlugin.js
index 6e149b33c3..e4967e91dd 100644
--- a/src/eventPlugins/EnterLeaveEventPlugin.js
+++ b/src/eventPlugins/EnterLeaveEventPlugin.js
@@ -19,11 +19,11 @@
 
 "use strict";
 
+var EventConstants = require('EventConstants');
 var EventPropagators = require('EventPropagators');
 var ExecutionEnvironment = require('ExecutionEnvironment');
-var AbstractEvent = require('AbstractEvent');
-var EventConstants = require('EventConstants');
 var ReactInstanceHandles = require('ReactInstanceHandles');
+var SyntheticMouseEvent = require('SyntheticMouseEvent');
 
 var getDOMNodeID = require('getDOMNodeID');
 var keyOf = require('keyOf');
@@ -31,78 +31,77 @@ var keyOf = require('keyOf');
 var topLevelTypes = EventConstants.topLevelTypes;
 var getFirstReactDOM = ReactInstanceHandles.getFirstReactDOM;
 
-var abstractEventTypes = {
+var eventTypes = {
   mouseEnter: {registrationName: keyOf({onMouseEnter: null})},
   mouseLeave: {registrationName: keyOf({onMouseLeave: null})}
 };
 
-/**
- * For almost every interaction we care about, there will be a top-level
- * `mouseover` and `mouseout` event that occurs so only pay attention to one of
- * the two (to avoid duplicate events). We use the `mouseout` event.
- *
- * However, there's one interaction where there will be no `mouseout` event to
- * rely on - mousing from outside the browser *into* the chrome. We detect this
- * scenario and only in that case, we use the `mouseover` event.
- *
- * @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 `AbstractEvent`s.
- * @see {EventPluginHub.extractEvents}
- */
-var extractEvents = function(
-    topLevelType,
-    topLevelTarget,
-    topLevelTargetID,
-    nativeEvent) {
-  if (topLevelType === topLevelTypes.topMouseOver &&
-      (nativeEvent.relatedTarget || nativeEvent.fromElement)) {
-    return null;
-  }
-  if (topLevelType !== topLevelTypes.topMouseOut &&
-      topLevelType !== topLevelTypes.topMouseOver) {
-    return null;  // Must not be a mouse in or mouse out - ignoring.
-  }
-
-  var to, from;
-  if (topLevelType === topLevelTypes.topMouseOut) {
-    to = getFirstReactDOM(nativeEvent.relatedTarget || nativeEvent.toElement) ||
-      ExecutionEnvironment.global;
-    from = topLevelTarget;
-  } else {
-    to = topLevelTarget;
-    from = ExecutionEnvironment.global;
-  }
-
-  // Nothing pertains to our managed components.
-  if (from === to) {
-    return null;
-  }
-
-  var fromID = from ? getDOMNodeID(from) : '';
-  var toID = to ? getDOMNodeID(to) : '';
-
-  var leave = AbstractEvent.getPooled(
-    abstractEventTypes.mouseLeave,
-    fromID,
-    nativeEvent
-  );
-  var enter = AbstractEvent.getPooled(
-    abstractEventTypes.mouseEnter,
-    toID,
-    nativeEvent
-  );
-
-  EventPropagators.accumulateEnterLeaveDispatches(leave, enter, fromID, toID);
-
-  return [leave, enter];
-};
-
 var EnterLeaveEventPlugin = {
-  abstractEventTypes: abstractEventTypes,
-  extractEvents: extractEvents
+
+  eventTypes: eventTypes,
+
+  /**
+   * For almost every interaction we care about, there will be both a top-level
+   * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
+   * we do not extract duplicate events. However, moving the mouse into the
+   * browser from outside will not fire a `mouseout` event. In this case, we use
+   * the `mouseover` top-level event.
+   *
+   * @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) {
+    if (topLevelType === topLevelTypes.topMouseOver &&
+        (nativeEvent.relatedTarget || nativeEvent.fromElement)) {
+      return null;
+    }
+    if (topLevelType !== topLevelTypes.topMouseOut &&
+        topLevelType !== topLevelTypes.topMouseOver) {
+      // Must not be a mouse in or mouse out - ignoring.
+      return null;
+    }
+
+    var from, to;
+    if (topLevelType === topLevelTypes.topMouseOut) {
+      from = topLevelTarget;
+      to = getFirstReactDOM(nativeEvent.relatedTarget || nativeEvent.toElement)
+        || ExecutionEnvironment.global;
+    } else {
+      from = ExecutionEnvironment.global;
+      to = topLevelTarget;
+    }
+
+    if (from === to) {
+      // Nothing pertains to our managed components.
+      return null;
+    }
+
+    var fromID = from ? getDOMNodeID(from) : '';
+    var toID = to ? getDOMNodeID(to) : '';
+
+    var leave = SyntheticMouseEvent.getPooled(
+      eventTypes.mouseLeave,
+      fromID,
+      nativeEvent
+    );
+    var enter = SyntheticMouseEvent.getPooled(
+      eventTypes.mouseEnter,
+      toID,
+      nativeEvent
+    );
+
+    EventPropagators.accumulateEnterLeaveDispatches(leave, enter, fromID, toID);
+    return [leave, enter];
+  }
+
 };
 
 module.exports = EnterLeaveEventPlugin;
diff --git a/src/eventPlugins/ResponderEventPlugin.js b/src/eventPlugins/ResponderEventPlugin.js
index 235b381211..ec55663ca4 100644
--- a/src/eventPlugins/ResponderEventPlugin.js
+++ b/src/eventPlugins/ResponderEventPlugin.js
@@ -18,10 +18,10 @@
 
 "use strict";
 
-var AbstractEvent = require('AbstractEvent');
 var EventConstants = require('EventConstants');
 var EventPluginUtils = require('EventPluginUtils');
 var EventPropagators = require('EventPropagators');
+var SyntheticEvent = require('SyntheticEvent');
 
 var accumulate = require('accumulate');
 var keyOf = require('keyOf');
@@ -41,11 +41,7 @@ var executeDispatchesInOrderStopAtTrue =
 var responderID = null;
 var isPressing = false;
 
-var getResponderID = function() {
-  return responderID;
-};
-
-var abstractEventTypes = {
+var eventTypes = {
   /**
    * On a `touchStart`/`mouseDown`, is it desired that this element become the
    * responder?
@@ -116,22 +112,22 @@ var abstractEventTypes = {
  *   `extractEvents()`.
  * - These events that are returned from `extractEvents` are "deferred
  *   dispatched events".
- * - When returned from `extractEvents`, deferred dispatched events
- *   contain an "accumulation" of deferred dispatches.
- * -- These deferred dispatches are accumulated/collected before they are
- *  returned, but processed at a later time by the `EventPluginHub` (hence the
- *  name deferred).
+ * - When returned from `extractEvents`, deferred-dispatched events contain an
+ *   "accumulation" of deferred dispatches.
+ * - These deferred dispatches are accumulated/collected before they are
+ *   returned, but processed at a later time by the `EventPluginHub` (hence the
+ *   name deferred).
  *
- * In the process of returning their deferred dispatched events, event plugins
+ * In the process of returning their deferred-dispatched events, event plugins
  * themselves can dispatch events on-demand without returning them from
- * `extractEvents`. Plugins might want to do this, so that they can use
- * event dispatching as a tool that helps them decide which events should be
- * extracted in the first place.
+ * `extractEvents`. Plugins might want to do this, so that they can use event
+ * dispatching as a tool that helps them decide which events should be extracted
+ * in the first place.
  *
  * "On-Demand-Dispatched Events":
  *
- * - On-demand dispatched are not returned from `extractEvents`.
- * - On-demand dispatched events are dispatched during the process of returning
+ * - On-demand-dispatched events are not returned from `extractEvents`.
+ * - On-demand-dispatched events are dispatched during the process of returning
  *   the deferred-dispatched events.
  * - They should not have side effects.
  * - They should be avoided, and/or eventually be replaced with another
@@ -158,81 +154,81 @@ var abstractEventTypes = {
  * - `touchStart`              (`EventPluginHub` dispatches as usual)
  * - `responderGrant/Reject`   (`EventPluginHub` dispatches as usual)
  *
- * @returns {Accumulation<AbstractEvent>}
- */
-
-/**
  * @param {string} topLevelType Record from `EventConstants`.
- * @param {string} renderedTargetID ID of deepest React rendered element.
+ * @param {string} topLevelTargetID ID of deepest React rendered element.
  * @param {object} nativeEvent Native browser event.
- * @return {*} An accumulation of extracted `AbstractEvent`s.
+ * @return {*} An accumulation of synthetic events.
  */
-var setResponderAndExtractTransfer =
-  function(topLevelType, renderedTargetID, nativeEvent) {
-    var type;
-    var shouldSetEventType =
-      isStartish(topLevelType) ? abstractEventTypes.startShouldSetResponder :
-      isMoveish(topLevelType) ? abstractEventTypes.moveShouldSetResponder :
-      abstractEventTypes.scrollShouldSetResponder;
+function setResponderAndExtractTransfer(
+    topLevelType,
+    topLevelTargetID,
+    nativeEvent) {
+  var shouldSetEventType =
+    isStartish(topLevelType) ? eventTypes.startShouldSetResponder :
+    isMoveish(topLevelType) ? eventTypes.moveShouldSetResponder :
+    eventTypes.scrollShouldSetResponder;
 
-    var bubbleShouldSetFrom = responderID || renderedTargetID;
-    var shouldSetEvent = AbstractEvent.getPooled(
-      shouldSetEventType,
-      bubbleShouldSetFrom,
-      topLevelType,
-      nativeEvent,
-      AbstractEvent.normalizePointerData(nativeEvent)
-    );
-    EventPropagators.accumulateTwoPhaseDispatches(shouldSetEvent);
-    var wantsResponderID = executeDispatchesInOrderStopAtTrue(shouldSetEvent);
-    AbstractEvent.release(shouldSetEvent);
+  var bubbleShouldSetFrom = responderID || topLevelTargetID;
+  var shouldSetEvent = SyntheticEvent.getPooled(
+    shouldSetEventType,
+    bubbleShouldSetFrom,
+    nativeEvent
+  );
+  EventPropagators.accumulateTwoPhaseDispatches(shouldSetEvent);
+  var wantsResponderID = executeDispatchesInOrderStopAtTrue(shouldSetEvent);
+  if (!shouldSetEvent.isPersistent()) {
+    shouldSetEvent.constructor.release(shouldSetEvent);
+  }
 
-    if (!wantsResponderID || wantsResponderID === responderID) {
-      return null;
-    }
-    var extracted;
-    var grantEvent = AbstractEvent.getPooled(
-      abstractEventTypes.responderGrant,
-      wantsResponderID,
-      topLevelType,
+  if (!wantsResponderID || wantsResponderID === responderID) {
+    return null;
+  }
+  var extracted;
+  var grantEvent = SyntheticEvent.getPooled(
+    eventTypes.responderGrant,
+    wantsResponderID,
+    nativeEvent
+  );
+
+  EventPropagators.accumulateDirectDispatches(grantEvent);
+  if (responderID) {
+    var terminationRequestEvent = SyntheticEvent.getPooled(
+      eventTypes.responderTerminationRequest,
+      responderID,
       nativeEvent
     );
-
-    EventPropagators.accumulateDirectDispatches(grantEvent);
-    if (responderID) {
-      type = abstractEventTypes.responderTerminationRequest;
-      var terminationRequestEvent = AbstractEvent.getPooled(type, responderID);
-      EventPropagators.accumulateDirectDispatches(terminationRequestEvent);
-      var shouldSwitch = !hasDispatches(terminationRequestEvent) ||
-        executeDirectDispatch(terminationRequestEvent);
-      AbstractEvent.release(terminationRequestEvent);
-      if (shouldSwitch) {
-        var terminateType = abstractEventTypes.responderTerminate;
-        var terminateEvent = AbstractEvent.getPooled(
-          terminateType,
-          responderID,
-          topLevelType,
-          nativeEvent
-        );
-        EventPropagators.accumulateDirectDispatches(terminateEvent);
-        extracted = accumulate(extracted, [grantEvent, terminateEvent]);
-        responderID = wantsResponderID;
-      } else {
-        var rejectEvent = AbstractEvent.getPooled(
-          abstractEventTypes.responderReject,
-          wantsResponderID,
-          topLevelType,
-          nativeEvent
-        );
-        EventPropagators.accumulateDirectDispatches(rejectEvent);
-        extracted = accumulate(extracted, rejectEvent);
-      }
-    } else {
-      extracted = accumulate(extracted, grantEvent);
-      responderID = wantsResponderID;
+    EventPropagators.accumulateDirectDispatches(terminationRequestEvent);
+    var shouldSwitch = !hasDispatches(terminationRequestEvent) ||
+      executeDirectDispatch(terminationRequestEvent);
+    if (!terminationRequestEvent.isPersistent()) {
+      terminationRequestEvent.constructor.release(terminationRequestEvent);
     }
-    return extracted;
-  };
+
+    if (shouldSwitch) {
+      var terminateType = eventTypes.responderTerminate;
+      var terminateEvent = SyntheticEvent.getPooled(
+        terminateType,
+        responderID,
+        nativeEvent
+      );
+      EventPropagators.accumulateDirectDispatches(terminateEvent);
+      extracted = accumulate(extracted, [grantEvent, terminateEvent]);
+      responderID = wantsResponderID;
+    } else {
+      var rejectEvent = SyntheticEvent.getPooled(
+        eventTypes.responderReject,
+        wantsResponderID,
+        nativeEvent
+      );
+      EventPropagators.accumulateDirectDispatches(rejectEvent);
+      extracted = accumulate(extracted, rejectEvent);
+    }
+  } else {
+    extracted = accumulate(extracted, grantEvent);
+    responderID = wantsResponderID;
+  }
+  return extracted;
+}
 
 /**
  * A transfer is a negotiation between a currently set responder and the next
@@ -241,9 +237,8 @@ var setResponderAndExtractTransfer =
  * currently a responder set (in other words as long as the user is pressing
  * down).
  *
- * @param {EventConstants.topLevelTypes} topLevelType
- * @return {boolean} Whether or not a transfer of responder could possibly
- * occur.
+ * @param {string} topLevelType Record from `EventConstants`.
+ * @return {boolean} True if a transfer of responder could possibly occur.
  */
 function canTriggerTransfer(topLevelType) {
   return topLevelType === EventConstants.topLevelTypes.topScroll ||
@@ -251,69 +246,71 @@ function canTriggerTransfer(topLevelType) {
          (isPressing && isMoveish(topLevelType));
 }
 
-/**
- * @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 `AbstractEvent`s.
- * @see {EventPluginHub.extractEvents}
- */
-var extractEvents = function(
-    topLevelType,
-    topLevelTarget,
-    topLevelTargetID,
-    nativeEvent) {
-  var extracted;
-  // Must have missed an end event - reset the state here.
-  if (responderID && isStartish(topLevelType)) {
-    responderID = null;
-  }
-  if (isStartish(topLevelType)) {
-    isPressing = true;
-  } else if (isEndish(topLevelType)) {
-    isPressing = false;
-  }
-  if (canTriggerTransfer(topLevelType)) {
-    var transfer = setResponderAndExtractTransfer(
-      topLevelType,
-      topLevelTargetID,
-      nativeEvent
-    );
-    if (transfer) {
-      extracted = accumulate(extracted, transfer);
-    }
-  }
-  // Now that we know the responder is set correctly, we can dispatch
-  // responder type events (directly to the responder).
-  var type = isMoveish(topLevelType) ? abstractEventTypes.responderMove :
-    isEndish(topLevelType) ? abstractEventTypes.responderRelease :
-    isStartish(topLevelType) ? abstractEventTypes.responderStart : null;
-  if (type) {
-    var data = AbstractEvent.normalizePointerData(nativeEvent);
-    var gesture = AbstractEvent.getPooled(
-      type,
-      responderID,
-      nativeEvent,
-      data
-    );
-    EventPropagators.accumulateDirectDispatches(gesture);
-    extracted = accumulate(extracted, gesture);
-  }
-  if (type === abstractEventTypes.responderRelease) {
-    responderID = null;
-  }
-  return extracted;
-};
-
 /**
  * Event plugin for formalizing the negotiation between claiming locks on
  * receiving touches.
  */
 var ResponderEventPlugin = {
-  abstractEventTypes: abstractEventTypes,
-  extractEvents: extractEvents,
-  getResponderID: getResponderID
+
+  getResponderID: function() {
+    return responderID;
+  },
+
+  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) {
+    var extracted;
+    // Must have missed an end event - reset the state here.
+    if (responderID && isStartish(topLevelType)) {
+      responderID = null;
+    }
+    if (isStartish(topLevelType)) {
+      isPressing = true;
+    } else if (isEndish(topLevelType)) {
+      isPressing = false;
+    }
+    if (canTriggerTransfer(topLevelType)) {
+      var transfer = setResponderAndExtractTransfer(
+        topLevelType,
+        topLevelTargetID,
+        nativeEvent
+      );
+      if (transfer) {
+        extracted = accumulate(extracted, transfer);
+      }
+    }
+    // Now that we know the responder is set correctly, we can dispatch
+    // responder type events (directly to the responder).
+    var type = isMoveish(topLevelType) ? eventTypes.responderMove :
+      isEndish(topLevelType) ? eventTypes.responderRelease :
+      isStartish(topLevelType) ? eventTypes.responderStart : null;
+    if (type) {
+      var gesture = SyntheticEvent.getPooled(
+        type,
+        responderID || '',
+        nativeEvent
+      );
+      EventPropagators.accumulateDirectDispatches(gesture);
+      extracted = accumulate(extracted, gesture);
+    }
+    if (type === eventTypes.responderRelease) {
+      responderID = null;
+    }
+    return extracted;
+  }
+
 };
 
 module.exports = ResponderEventPlugin;
diff --git a/src/eventPlugins/SimpleEventPlugin.js b/src/eventPlugins/SimpleEventPlugin.js
index 490dce2172..3f37f23246 100644
--- a/src/eventPlugins/SimpleEventPlugin.js
+++ b/src/eventPlugins/SimpleEventPlugin.js
@@ -18,201 +18,237 @@
 
 "use strict";
 
-var AbstractEvent = require('AbstractEvent');
 var EventConstants = require('EventConstants');
 var EventPropagators = require('EventPropagators');
+var SyntheticEvent = require('SyntheticEvent');
+var SyntheticFocusEvent = require('SyntheticFocusEvent');
+var SyntheticKeyboardEvent = require('SyntheticKeyboardEvent');
+var SyntheticMouseEvent = require('SyntheticMouseEvent');
+var SyntheticMutationEvent = require('SyntheticMutationEvent');
+var SyntheticTouchEvent = require('SyntheticTouchEvent');
+var SyntheticUIEvent = require('SyntheticUIEvent');
+var SyntheticWheelEvent = require('SyntheticWheelEvent');
 
+var invariant = require('invariant');
 var keyOf = require('keyOf');
 
 var topLevelTypes = EventConstants.topLevelTypes;
 
-var SimpleEventPlugin = {
-  abstractEventTypes: {
-    // Note: We do not allow listening to mouseOver events. Instead, use the
-    // onMouseEnter/onMouseLeave created by `EnterLeaveEventPlugin`.
-    mouseDown: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onMouseDown: true}),
-        captured: keyOf({onMouseDownCapture: true})
-      }
-    },
-    mouseUp: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onMouseUp: true}),
-        captured: keyOf({onMouseUpCapture: true})
-      }
-    },
-    mouseMove: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onMouseMove: true}),
-        captured: keyOf({onMouseMoveCapture: true})
-      }
-    },
-    doubleClick: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onDoubleClick: true}),
-        captured: keyOf({onDoubleClickCapture: true})
-      }
-    },
-    click: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onClick: true}),
-        captured: keyOf({onClickCapture: true})
-      }
-    },
-    wheel: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onWheel: true}),
-        captured: keyOf({onWheelCapture: true})
-      }
-    },
-    touchStart: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onTouchStart: true}),
-        captured: keyOf({onTouchStartCapture: true})
-      }
-    },
-    touchEnd: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onTouchEnd: true}),
-        captured: keyOf({onTouchEndCapture: true})
-      }
-    },
-    touchCancel: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onTouchCancel: true}),
-        captured: keyOf({onTouchCancelCapture: true})
-      }
-    },
-    touchMove: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onTouchMove: true}),
-        captured: keyOf({onTouchMoveCapture: true})
-      }
-    },
-    keyUp: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onKeyUp: true}),
-        captured: keyOf({onKeyUpCapture: true})
-      }
-    },
-    keyPress: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onKeyPress: true}),
-        captured: keyOf({onKeyPressCapture: true})
-      }
-    },
-    keyDown: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onKeyDown: true}),
-        captured: keyOf({onKeyDownCapture: true})
-      }
-    },
-    input: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onInput: true}),
-        captured: keyOf({onInputCapture: true})
-      }
-    },
-    focus: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onFocus: true}),
-        captured: keyOf({onFocusCapture: true})
-      }
-    },
-    blur: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onBlur: true}),
-        captured: keyOf({onBlurCapture: true})
-      }
-    },
-    scroll: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onScroll: true}),
-        captured: keyOf({onScrollCapture: true})
-      }
-    },
-    change: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onChange: true}),
-        captured: keyOf({onChangeCapture: true})
-      }
-    },
-    submit: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onSubmit: true}),
-        captured: keyOf({onSubmitCapture: true})
-      }
-    },
-    DOMCharacterDataModified: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onDOMCharacterDataModified: true}),
-        captured: keyOf({onDOMCharacterDataModifiedCapture: true})
-      }
-    },
-    drag: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onDrag: true}),
-        captured: keyOf({onDragCapture: true})
-      }
-    },
-    dragEnd: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onDragEnd: true}),
-        captured: keyOf({onDragEndCapture: true})
-      }
-    },
-    dragEnter: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onDragEnter: true}),
-        captured: keyOf({onDragEnterCapture: true})
-      }
-    },
-    dragExit: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onDragExit: true}),
-        captured: keyOf({onDragExitCapture: true})
-      }
-    },
-    dragLeave: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onDragLeave: true}),
-        captured: keyOf({onDragLeaveCapture: true})
-      }
-    },
-    dragOver: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onDragOver: true}),
-        captured: keyOf({onDragOverCapture: true})
-      }
-    },
-    dragStart: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onDragStart: true}),
-        captured: keyOf({onDragStartCapture: true})
-      }
-    },
-    drop: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onDrop: true}),
-        captured: keyOf({onDropCapture: true})
-      }
+var eventTypes = {
+  blur: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onBlur: true}),
+      captured: keyOf({onBlurCapture: true})
     }
   },
+  change: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onChange: true}),
+      captured: keyOf({onChangeCapture: true})
+    }
+  },
+  click: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onClick: true}),
+      captured: keyOf({onClickCapture: true})
+    }
+  },
+  doubleClick: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onDoubleClick: true}),
+      captured: keyOf({onDoubleClickCapture: true})
+    }
+  },
+  drag: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onDrag: true}),
+      captured: keyOf({onDragCapture: true})
+    }
+  },
+  dragEnd: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onDragEnd: true}),
+      captured: keyOf({onDragEndCapture: true})
+    }
+  },
+  dragEnter: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onDragEnter: true}),
+      captured: keyOf({onDragEnterCapture: true})
+    }
+  },
+  dragExit: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onDragExit: true}),
+      captured: keyOf({onDragExitCapture: true})
+    }
+  },
+  dragLeave: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onDragLeave: true}),
+      captured: keyOf({onDragLeaveCapture: true})
+    }
+  },
+  dragOver: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onDragOver: true}),
+      captured: keyOf({onDragOverCapture: true})
+    }
+  },
+  dragStart: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onDragStart: true}),
+      captured: keyOf({onDragStartCapture: true})
+    }
+  },
+  drop: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onDrop: true}),
+      captured: keyOf({onDropCapture: true})
+    }
+  },
+  focus: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onFocus: true}),
+      captured: keyOf({onFocusCapture: true})
+    }
+  },
+  input: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onInput: true}),
+      captured: keyOf({onInputCapture: true})
+    }
+  },
+  keyDown: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onKeyDown: true}),
+      captured: keyOf({onKeyDownCapture: true})
+    }
+  },
+  keyPress: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onKeyPress: true}),
+      captured: keyOf({onKeyPressCapture: true})
+    }
+  },
+  keyUp: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onKeyUp: true}),
+      captured: keyOf({onKeyUpCapture: true})
+    }
+  },
+  // Note: We do not allow listening to mouseOver events. Instead, use the
+  // onMouseEnter/onMouseLeave created by `EnterLeaveEventPlugin`.
+  mouseDown: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onMouseDown: true}),
+      captured: keyOf({onMouseDownCapture: true})
+    }
+  },
+  mouseMove: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onMouseMove: true}),
+      captured: keyOf({onMouseMoveCapture: true})
+    }
+  },
+  mouseUp: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onMouseUp: true}),
+      captured: keyOf({onMouseUpCapture: true})
+    }
+  },
+  scroll: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onScroll: true}),
+      captured: keyOf({onScrollCapture: true})
+    }
+  },
+  submit: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onSubmit: true}),
+      captured: keyOf({onSubmitCapture: true})
+    }
+  },
+  touchCancel: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onTouchCancel: true}),
+      captured: keyOf({onTouchCancelCapture: true})
+    }
+  },
+  touchEnd: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onTouchEnd: true}),
+      captured: keyOf({onTouchEndCapture: true})
+    }
+  },
+  touchMove: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onTouchMove: true}),
+      captured: keyOf({onTouchMoveCapture: true})
+    }
+  },
+  touchStart: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onTouchStart: true}),
+      captured: keyOf({onTouchStartCapture: true})
+    }
+  },
+  wheel: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onWheel: true}),
+      captured: keyOf({onWheelCapture: true})
+    }
+  }
+};
+
+var topLevelEventsToDispatchConfig = {
+  topBlur:        eventTypes.blur,
+  topChange:      eventTypes.change,
+  topClick:       eventTypes.click,
+  topDoubleClick: eventTypes.doubleClick,
+  topDOMCharacterDataModified: eventTypes.DOMCharacterDataModified,
+  topDrag:        eventTypes.drag,
+  topDragEnd:     eventTypes.dragEnd,
+  topDragEnter:   eventTypes.dragEnter,
+  topDragExit:    eventTypes.dragExit,
+  topDragLeave:   eventTypes.dragLeave,
+  topDragOver:    eventTypes.dragOver,
+  topDragStart:   eventTypes.dragStart,
+  topDrop:        eventTypes.drop,
+  topFocus:       eventTypes.focus,
+  topInput:       eventTypes.input,
+  topKeyDown:     eventTypes.keyDown,
+  topKeyPress:    eventTypes.keyPress,
+  topKeyUp:       eventTypes.keyUp,
+  topMouseDown:   eventTypes.mouseDown,
+  topMouseMove:   eventTypes.mouseMove,
+  topMouseUp:     eventTypes.mouseUp,
+  topScroll:      eventTypes.scroll,
+  topSubmit:      eventTypes.submit,
+  topTouchCancel: eventTypes.touchCancel,
+  topTouchEnd:    eventTypes.touchEnd,
+  topTouchMove:   eventTypes.touchMove,
+  topTouchStart:  eventTypes.touchStart,
+  topWheel:       eventTypes.wheel
+};
+
+var SimpleEventPlugin = {
+
+  eventTypes: eventTypes,
 
   /**
    * Same as the default implementation, except cancels the event when return
    * value is false.
    *
-   * @param {AbstractEvent} AbstractEvent to handle
-   * @param {function} Application-level callback
-   * @param {string} domID DOM id to pass to the callback.
+   * @param {object} Event to be dispatched.
+   * @param {function} Application-level callback.
+   * @param {string} domID DOM ID to pass to the callback.
    */
-  executeDispatch: function(abstractEvent, listener, domID) {
-    var returnValue = listener(abstractEvent, domID);
+  executeDispatch: function(event, listener, domID) {
+    var returnValue = listener(event, domID);
     if (returnValue === false) {
-      abstractEvent.stopPropagation();
-      abstractEvent.preventDefault();
+      event.stopPropagation();
+      event.preventDefault();
     }
   },
 
@@ -221,7 +257,7 @@ var SimpleEventPlugin = {
    * @param {DOMEventTarget} topLevelTarget The listening component root node.
    * @param {string} topLevelTargetID ID of `topLevelTarget`.
    * @param {object} nativeEvent Native browser event.
-   * @return {*} An accumulation of `AbstractEvent`s.
+   * @return {*} An accumulation of synthetic events.
    * @see {EventPluginHub.extractEvents}
    */
   extractEvents: function(
@@ -229,29 +265,30 @@ var SimpleEventPlugin = {
       topLevelTarget,
       topLevelTargetID,
       nativeEvent) {
-    var data;
-    var abstractEventType =
-      SimpleEventPlugin.topLevelTypesToAbstract[topLevelType];
-    if (!abstractEventType) {
+    var dispatchConfig = topLevelEventsToDispatchConfig[topLevelType];
+    if (!dispatchConfig) {
       return null;
     }
+    var EventConstructor;
     switch(topLevelType) {
-      case topLevelTypes.topWheel:
-        data = AbstractEvent.normalizeMouseWheelData(nativeEvent);
+      case topLevelTypes.topChange:
+      case topLevelTypes.topInput:
+      case topLevelTypes.topSubmit:
+        // HTML Events
+        // @see http://www.w3.org/TR/html5/index.html#events-0
+        EventConstructor = SyntheticEvent;
         break;
-      case topLevelTypes.topScroll:
-        data = AbstractEvent.normalizeScrollDataFromTarget(topLevelTarget);
+      case topLevelTypes.topKeyDown:
+      case topLevelTypes.topKeyPress:
+      case topLevelTypes.topKeyUp:
+        EventConstructor = SyntheticKeyboardEvent;
+        break;
+      case topLevelTypes.topBlur:
+      case topLevelTypes.topFocus:
+        EventConstructor = SyntheticFocusEvent;
         break;
       case topLevelTypes.topClick:
       case topLevelTypes.topDoubleClick:
-      case topLevelTypes.topChange:
-      case topLevelTypes.topDOMCharacterDataModified:
-      case topLevelTypes.topMouseDown:
-      case topLevelTypes.topMouseUp:
-      case topLevelTypes.topMouseMove:
-      case topLevelTypes.topTouchMove:
-      case topLevelTypes.topTouchStart:
-      case topLevelTypes.topTouchEnd:
       case topLevelTypes.topDrag:
       case topLevelTypes.topDragEnd:
       case topLevelTypes.topDragEnter:
@@ -260,53 +297,41 @@ var SimpleEventPlugin = {
       case topLevelTypes.topDragOver:
       case topLevelTypes.topDragStart:
       case topLevelTypes.topDrop:
-        data = AbstractEvent.normalizePointerData(nativeEvent);
-        // todo: Use AbstractEvent.normalizeDragEventData for drag/drop?
+      case topLevelTypes.topMouseDown:
+      case topLevelTypes.topMouseMove:
+      case topLevelTypes.topMouseUp:
+        EventConstructor = SyntheticMouseEvent;
+        break;
+      case topLevelTypes.topDOMCharacterDataModified:
+        EventConstructor = SyntheticMutationEvent;
+        break;
+      case topLevelTypes.topTouchCancel:
+      case topLevelTypes.topTouchEnd:
+      case topLevelTypes.topTouchMove:
+      case topLevelTypes.topTouchStart:
+        EventConstructor = SyntheticTouchEvent;
+        break;
+      case topLevelTypes.topScroll:
+        EventConstructor = SyntheticUIEvent;
+        break;
+      case topLevelTypes.topWheel:
+        EventConstructor = SyntheticWheelEvent;
         break;
-      default:
-        data = null;
     }
-    var abstractEvent = AbstractEvent.getPooled(
-      abstractEventType,
-      topLevelTargetID,
-      nativeEvent,
-      data
+    invariant(
+      EventConstructor,
+      'SimpleEventPlugin: Unhandled event type, `%s`.',
+      topLevelType
     );
-    EventPropagators.accumulateTwoPhaseDispatches(abstractEvent);
-    return abstractEvent;
+    var event = EventConstructor.getPooled(
+      dispatchConfig,
+      topLevelTargetID,
+      nativeEvent
+    );
+    EventPropagators.accumulateTwoPhaseDispatches(event);
+    return event;
   }
-};
 
-SimpleEventPlugin.topLevelTypesToAbstract = {
-  topMouseDown:   SimpleEventPlugin.abstractEventTypes.mouseDown,
-  topMouseUp:     SimpleEventPlugin.abstractEventTypes.mouseUp,
-  topMouseMove:   SimpleEventPlugin.abstractEventTypes.mouseMove,
-  topClick:       SimpleEventPlugin.abstractEventTypes.click,
-  topDoubleClick: SimpleEventPlugin.abstractEventTypes.doubleClick,
-  topWheel:       SimpleEventPlugin.abstractEventTypes.wheel,
-  topTouchStart:  SimpleEventPlugin.abstractEventTypes.touchStart,
-  topTouchEnd:    SimpleEventPlugin.abstractEventTypes.touchEnd,
-  topTouchMove:   SimpleEventPlugin.abstractEventTypes.touchMove,
-  topTouchCancel: SimpleEventPlugin.abstractEventTypes.touchCancel,
-  topKeyUp:       SimpleEventPlugin.abstractEventTypes.keyUp,
-  topKeyPress:    SimpleEventPlugin.abstractEventTypes.keyPress,
-  topKeyDown:     SimpleEventPlugin.abstractEventTypes.keyDown,
-  topInput:       SimpleEventPlugin.abstractEventTypes.input,
-  topFocus:       SimpleEventPlugin.abstractEventTypes.focus,
-  topBlur:        SimpleEventPlugin.abstractEventTypes.blur,
-  topScroll:      SimpleEventPlugin.abstractEventTypes.scroll,
-  topChange:      SimpleEventPlugin.abstractEventTypes.change,
-  topSubmit:      SimpleEventPlugin.abstractEventTypes.submit,
-  topDOMCharacterDataModified:
-                  SimpleEventPlugin.abstractEventTypes.DOMCharacterDataModified,
-  topDrag:        SimpleEventPlugin.abstractEventTypes.drag,
-  topDragEnd:     SimpleEventPlugin.abstractEventTypes.dragEnd,
-  topDragEnter:   SimpleEventPlugin.abstractEventTypes.dragEnter,
-  topDragExit:    SimpleEventPlugin.abstractEventTypes.dragExit,
-  topDragLeave:   SimpleEventPlugin.abstractEventTypes.dragLeave,
-  topDragOver:    SimpleEventPlugin.abstractEventTypes.dragOver,
-  topDragStart:   SimpleEventPlugin.abstractEventTypes.dragStart,
-  topDrop:        SimpleEventPlugin.abstractEventTypes.drop
 };
 
 module.exports = SimpleEventPlugin;
diff --git a/src/eventPlugins/TapEventPlugin.js b/src/eventPlugins/TapEventPlugin.js
index c36732881a..03293eaf16 100644
--- a/src/eventPlugins/TapEventPlugin.js
+++ b/src/eventPlugins/TapEventPlugin.js
@@ -19,25 +19,49 @@
 
 "use strict";
 
-var AbstractEvent = require('AbstractEvent');
+var BrowserEnv = require('BrowserEnv');
 var EventPluginUtils = require('EventPluginUtils');
 var EventPropagators = require('EventPropagators');
+var SyntheticUIEvent = require('SyntheticUIEvent');
+var TouchEventUtils = require('TouchEventUtils');
 
 var keyOf = require('keyOf');
 
 var isStartish = EventPluginUtils.isStartish;
 var isEndish = EventPluginUtils.isEndish;
-var storePageCoordsIn = EventPluginUtils.storePageCoordsIn;
-var eventDistance = EventPluginUtils.eventDistance;
 
 /**
- * The number of pixels that are tolerated in between a touchStart and
- * touchEnd in order to still be considered a 'tap' event.
+ * Number of pixels that are tolerated in between a `touchStart` and `touchEnd`
+ * in order to still be considered a 'tap' event.
  */
 var tapMoveThreshold = 10;
 var startCoords = {x: null, y: null};
 
-var abstractEventTypes = {
+var Axis = {
+  x: {page: 'pageX', client: 'clientX', envScroll: 'currentPageScrollLeft'},
+  y: {page: 'pageY', client: 'clientY', envScroll: 'currentPageScrollTop'}
+};
+
+function getAxisCoordOfEvent(axis, nativeEvent) {
+  var singleTouch = TouchEventUtils.extractSingleTouch(nativeEvent);
+  if (singleTouch) {
+    return singleTouch[axis.page];
+  }
+  return axis.page in nativeEvent ?
+    nativeEvent[axis.page] :
+    nativeEvent[axis.client] + BrowserEnv[axis.envScroll];
+}
+
+function getDistance(coords, nativeEvent) {
+  var pageX = getAxisCoordOfEvent(Axis.x, nativeEvent);
+  var pageY = getAxisCoordOfEvent(Axis.y, nativeEvent);
+  return Math.pow(
+    Math.pow(pageX - coords.x, 2) + Math.pow(pageY - coords.y, 2),
+    0.5
+  );
+}
+
+var eventTypes = {
   touchTap: {
     phasedRegistrationNames: {
       bubbled: keyOf({onTouchTap: null}),
@@ -46,46 +70,48 @@ var abstractEventTypes = {
   }
 };
 
-/**
- * @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 `AbstractEvent`s.
- * @see {EventPluginHub.extractEvents}
- */
-var extractEvents = function(
-    topLevelType,
-    topLevelTarget,
-    topLevelTargetID,
-    nativeEvent) {
-  if (!isStartish(topLevelType) && !isEndish(topLevelType)) {
-    return;
-  }
-  var abstractEvent;
-  var dist = eventDistance(startCoords, nativeEvent);
-  if (isEndish(topLevelType) && dist < tapMoveThreshold) {
-    abstractEvent = AbstractEvent.getPooled(
-      abstractEventTypes.touchTap,
-      topLevelTargetID,
-      nativeEvent
-    );
-  }
-  if (isStartish(topLevelType)) {
-    storePageCoordsIn(startCoords, nativeEvent);
-  } else if (isEndish(topLevelType)) {
-    startCoords.x = 0;
-    startCoords.y = 0;
-  }
-  EventPropagators.accumulateTwoPhaseDispatches(abstractEvent);
-  return abstractEvent;
-};
-
 var TapEventPlugin = {
+
   tapMoveThreshold: tapMoveThreshold,
-  startCoords: startCoords,
-  abstractEventTypes: abstractEventTypes,
-  extractEvents: extractEvents
+
+  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) {
+    if (!isStartish(topLevelType) && !isEndish(topLevelType)) {
+      return null;
+    }
+    var event = null;
+    var distance = getDistance(startCoords, nativeEvent);
+    if (isEndish(topLevelType) && distance < tapMoveThreshold) {
+      event = SyntheticUIEvent.getPooled(
+        eventTypes.touchTap,
+        topLevelTargetID,
+        nativeEvent
+      );
+    }
+    if (isStartish(topLevelType)) {
+      startCoords.x = getAxisCoordOfEvent(Axis.x, nativeEvent);
+      startCoords.y = getAxisCoordOfEvent(Axis.y, nativeEvent);
+    } else if (isEndish(topLevelType)) {
+      startCoords.x = 0;
+      startCoords.y = 0;
+    }
+    EventPropagators.accumulateTwoPhaseDispatches(event);
+    return event;
+  }
+
 };
 
 module.exports = TapEventPlugin;
diff --git a/src/eventPlugins/TextChangeEventPlugin.js b/src/eventPlugins/TextChangeEventPlugin.js
index ced2eb1093..1502c38098 100644
--- a/src/eventPlugins/TextChangeEventPlugin.js
+++ b/src/eventPlugins/TextChangeEventPlugin.js
@@ -18,18 +18,18 @@
 
 "use strict";
 
-var AbstractEvent = require('AbstractEvent');
 var EventConstants = require('EventConstants');
 var EventPluginHub = require('EventPluginHub');
 var EventPropagators = require('EventPropagators');
 var ExecutionEnvironment = require('ExecutionEnvironment');
+var SyntheticEvent = require('SyntheticEvent');
 
 var isEventSupported = require('isEventSupported');
 var keyOf = require('keyOf');
 
 var topLevelTypes = EventConstants.topLevelTypes;
 
-var abstractEventTypes = {
+var eventTypes = {
   textChange: {
     phasedRegistrationNames: {
       bubbled: keyOf({onTextChange: null}),
@@ -121,29 +121,28 @@ var stopWatching = function() {
  * the value of the active element has changed.
  */
 var handlePropertyChange = function(nativeEvent) {
-  var value;
-  var abstractEvent;
-
-  if (nativeEvent.propertyName === "value") {
-    value = nativeEvent.srcElement.value;
-    if (value !== activeElementValue) {
-      activeElementValue = value;
-
-      abstractEvent = AbstractEvent.getPooled(
-        abstractEventTypes.textChange,
-        activeElementID,
-        nativeEvent
-      );
-      EventPropagators.accumulateTwoPhaseDispatches(abstractEvent);
-
-      // If propertychange bubbled, we'd just bind to it like all the other
-      // events and have it go through ReactEventTopLevelCallback. Since it
-      // doesn't, we manually listen for the propertychange event and so we
-      // have to enqueue and process the abstract event manually.
-      EventPluginHub.enqueueEvents(abstractEvent);
-      EventPluginHub.processEventQueue();
-    }
+  if (nativeEvent.propertyName !== "value") {
+    return;
   }
+  var value = nativeEvent.srcElement.value;
+  if (value === activeElementValue) {
+    return;
+  }
+  activeElementValue = value;
+
+  var event = SyntheticEvent.getPooled(
+    eventTypes.textChange,
+    activeElementID,
+    nativeEvent
+  );
+  EventPropagators.accumulateTwoPhaseDispatches(event);
+
+  // If propertychange bubbled, we'd just bind to it like all the other events
+  // and have it go through ReactEventTopLevelCallback. Since it doesn't, we
+  // manually listen for the propertychange event and so we have to enqueue and
+  // process the abstract event manually.
+  EventPluginHub.enqueueEvents(event);
+  EventPluginHub.processEventQueue();
 };
 
 /**
@@ -154,8 +153,7 @@ if (isInputSupported) {
   targetIDForTextChangeEvent = function(
       topLevelType,
       topLevelTarget,
-      topLevelTargetID,
-      nativeEvent) {
+      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...
@@ -171,8 +169,7 @@ if (isInputSupported) {
   targetIDForTextChangeEvent = function(
       topLevelType,
       topLevelTarget,
-      topLevelTargetID,
-      nativeEvent) {
+      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
@@ -214,40 +211,40 @@ if (isInputSupported) {
   };
 }
 
-/**
- * @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 `AbstractEvent`s.
- * @see {EventPluginHub.extractEvents}
- */
-var extractEvents = function(
-    topLevelType,
-    topLevelTarget,
-    topLevelTargetID,
-    nativeEvent) {
-  var targetID = targetIDForTextChangeEvent(
-    topLevelType,
-    topLevelTarget,
-    topLevelTargetID,
-    nativeEvent
-  );
-
-  if (targetID) {
-    var abstractEvent = AbstractEvent.getPooled(
-      abstractEventTypes.textChange,
-      targetID,
-      nativeEvent
-    );
-    EventPropagators.accumulateTwoPhaseDispatches(abstractEvent);
-    return abstractEvent;
-  }
-};
-
 var TextChangeEventPlugin = {
-  abstractEventTypes: abstractEventTypes,
-  extractEvents: extractEvents
+
+  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) {
+    var targetID = targetIDForTextChangeEvent(
+      topLevelType,
+      topLevelTarget,
+      topLevelTargetID
+    );
+
+    if (targetID) {
+      var event = SyntheticEvent.getPooled(
+        eventTypes.textChange,
+        targetID,
+        nativeEvent
+      );
+      EventPropagators.accumulateTwoPhaseDispatches(event);
+      return event;
+    }
+  }
+
 };
 
 module.exports = TextChangeEventPlugin;
diff --git a/src/eventPlugins/__tests__/ResponderEventPlugin-test.js b/src/eventPlugins/__tests__/ResponderEventPlugin-test.js
index baec2ae60a..6917e6e8b7 100644
--- a/src/eventPlugins/__tests__/ResponderEventPlugin-test.js
+++ b/src/eventPlugins/__tests__/ResponderEventPlugin-test.js
@@ -23,21 +23,21 @@ var EventConstants;
 var EventPropagators;
 var ReactInstanceHandles;
 var ResponderEventPlugin;
-var AbstractEvent;
+var SyntheticEvent;
 
 var GRANDPARENT_ID = '.reactRoot[0]';
 var PARENT_ID = '.reactRoot[0].0';
 var CHILD_ID = '.reactRoot[0].0.0';
 
 var topLevelTypes;
-var responderAbstractEventTypes;
+var responderEventTypes;
 var spies;
 
 var DUMMY_NATIVE_EVENT = {};
 var DUMMY_RENDERED_TARGET = {};
 
 var onStartShouldSetResponder = function(id, cb, capture) {
-  var registrationNames = responderAbstractEventTypes
+  var registrationNames = responderEventTypes
     .startShouldSetResponder
     .phasedRegistrationNames;
   CallbackRegistry.putListener(
@@ -48,7 +48,7 @@ var onStartShouldSetResponder = function(id, cb, capture) {
 };
 
 var onScrollShouldSetResponder = function(id, cb, capture) {
-  var registrationNames = responderAbstractEventTypes
+  var registrationNames = responderEventTypes
     .scrollShouldSetResponder
     .phasedRegistrationNames;
   CallbackRegistry.putListener(
@@ -59,7 +59,7 @@ var onScrollShouldSetResponder = function(id, cb, capture) {
 };
 
 var onMoveShouldSetResponder = function(id, cb, capture) {
-  var registrationNames = responderAbstractEventTypes
+  var registrationNames = responderEventTypes
     .moveShouldSetResponder
     .phasedRegistrationNames;
   CallbackRegistry.putListener(
@@ -73,7 +73,7 @@ var onMoveShouldSetResponder = function(id, cb, capture) {
 var onResponderGrant = function(id, cb) {
   CallbackRegistry.putListener(
     id,
-    responderAbstractEventTypes.responderGrant.registrationName,
+    responderEventTypes.responderGrant.registrationName,
     cb
   );
 };
@@ -165,44 +165,40 @@ var existsInExtraction = function(extracted, test) {
  * Helper validators.
  */
 function assertGrantEvent(id, extracted) {
-  var test = function(abstractEvent) {
-    return abstractEvent instanceof AbstractEvent &&
-      abstractEvent.reactEventType ===
-        responderAbstractEventTypes.responderGrant &&
-      abstractEvent.reactTargetID === id;
+  var test = function(event) {
+    return event instanceof SyntheticEvent &&
+      event.dispatchConfig === responderEventTypes.responderGrant &&
+      event.dispatchMarker === id;
   };
   expect(ResponderEventPlugin.getResponderID()).toBe(id);
   expect(existsInExtraction(extracted, test)).toBe(true);
 }
 
 function assertResponderMoveEvent(id, extracted) {
-  var test = function(abstractEvent) {
-    return abstractEvent instanceof AbstractEvent &&
-      abstractEvent.reactEventType ===
-        responderAbstractEventTypes.responderMove &&
-      abstractEvent.reactTargetID === id;
+  var test = function(event) {
+    return event instanceof SyntheticEvent &&
+      event.dispatchConfig === responderEventTypes.responderMove &&
+      event.dispatchMarker === id;
   };
   expect(ResponderEventPlugin.getResponderID()).toBe(id);
   expect(existsInExtraction(extracted, test)).toBe(true);
 }
 
 function assertTerminateEvent(id, extracted) {
-  var test = function(abstractEvent) {
-    return abstractEvent instanceof AbstractEvent &&
-      abstractEvent.reactEventType ===
-        responderAbstractEventTypes.responderTerminate &&
-      abstractEvent.reactTargetID === id;
+  var test = function(event) {
+    return event instanceof SyntheticEvent &&
+      event.dispatchConfig === responderEventTypes.responderTerminate &&
+      event.dispatchMarker === id;
   };
   expect(ResponderEventPlugin.getResponderID()).not.toBe(id);
   expect(existsInExtraction(extracted, test)).toBe(true);
 }
 
 function assertRelease(id, extracted) {
-  var test = function(abstractEvent) {
-    return abstractEvent instanceof AbstractEvent &&
-      abstractEvent.reactEventType ===
-        responderAbstractEventTypes.responderRelease &&
-      abstractEvent.reactTargetID === id;
+  var test = function(event) {
+    return event instanceof SyntheticEvent &&
+      event.dispatchConfig === responderEventTypes.responderRelease &&
+      event.dispatchMarker === id;
   };
   expect(ResponderEventPlugin.getResponderID()).toBe(null);
   expect(existsInExtraction(extracted, test)).toBe(true);
@@ -226,12 +222,12 @@ describe('ResponderEventPlugin', function() {
   beforeEach(function() {
     require('mock-modules').dumpCache();
 
-    AbstractEvent = require('AbstractEvent');
     CallbackRegistry = require('CallbackRegistry');
     EventConstants = require('EventConstants');
     EventPropagators = require('EventPropagators');
     ReactInstanceHandles = require('ReactInstanceHandles');
     ResponderEventPlugin = require('ResponderEventPlugin');
+    SyntheticEvent = require('SyntheticEvent');
     EventPropagators.injection.injectInstanceHandle(ReactInstanceHandles);
 
     // dumpCache, in open-source tests, only resets existing mocks. It does not
@@ -240,7 +236,7 @@ describe('ResponderEventPlugin', function() {
     CallbackRegistry.__purge();
 
     topLevelTypes = EventConstants.topLevelTypes;
-    responderAbstractEventTypes = ResponderEventPlugin.abstractEventTypes;
+    responderEventTypes = ResponderEventPlugin.eventTypes;
 
     spies = {
       onStartShouldSetResponderChild: function() {},
diff --git a/src/test/ReactTestUtils.js b/src/test/ReactTestUtils.js
index a3520ede64..95651d5c90 100644
--- a/src/test/ReactTestUtils.js
+++ b/src/test/ReactTestUtils.js
@@ -187,7 +187,7 @@ var ReactTestUtils = {
    * on and `Element` node.
    * @param topLevelType {Object} A type from `EventConstants.topLevelTypes`
    * @param {!Element} node The dom to simulate an event occurring on.
-   * @param {?Event} fakeNativeEvent Fake native event to pass to ReactEvent.
+   * @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent.
    */
   simulateEventOnNode: function(topLevelType, node, fakeNativeEvent) {
     var virtualHandler =
@@ -203,7 +203,7 @@ var ReactTestUtils = {
    * on the `ReactNativeComponent` `comp`.
    * @param topLevelType {Object} A type from `EventConstants.topLevelTypes`.
    * @param comp {!ReactNativeComponent}
-   * @param {?Event} fakeNativeEvent Fake native event to pass to ReactEvent.
+   * @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent.
    */
   simulateEventOnDOMComponent: function(topLevelType, comp, fakeNativeEvent) {
     var reactRootID = comp._rootNodeID || comp._rootDomId;
@@ -280,7 +280,7 @@ for (eventType in topLevelTypes) {
     eventType.charAt(3).toLowerCase() + eventType.substr(4) : eventType;
   /**
    * @param {!Element || ReactNativeComponent} domComponentOrNode
-   * @param {?Event} nativeEventData Fake native event to pass to ReactEvent.
+   * @param {?Event} nativeEventData Fake native event to use in SyntheticEvent.
    */
   ReactTestUtils.Simulate[convenienceName] = makeSimulator(eventType);
 }

From 0b1ecd88723e69c6ec48facb0087e06b086c070b Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 14 Jun 2013 16:45:25 -0700
Subject: [PATCH 17/94] Add Back `DOMCharacterDataModified`

Accidentally lost `DOMCharacterDataModified`.
---
 src/eventPlugins/SimpleEventPlugin.js | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/eventPlugins/SimpleEventPlugin.js b/src/eventPlugins/SimpleEventPlugin.js
index 3f37f23246..bca0d4604a 100644
--- a/src/eventPlugins/SimpleEventPlugin.js
+++ b/src/eventPlugins/SimpleEventPlugin.js
@@ -107,6 +107,12 @@ var eventTypes = {
       captured: keyOf({onDropCapture: true})
     }
   },
+  DOMCharacterDataModified: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({onDOMCharacterDataModified: true}),
+      captured: keyOf({onDOMCharacterDataModifiedCapture: true})
+    }
+  },
   focus: {
     phasedRegistrationNames: {
       bubbled: keyOf({onFocus: true}),

From c04081bc562047f796a72ad372791b411b971985 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 17 Jun 2013 12:47:29 -0700
Subject: [PATCH 18/94] Add missing license header.

---
 src/utils/onlyChild.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/utils/onlyChild.js b/src/utils/onlyChild.js
index 9e4f36e223..2a78dcbfda 100644
--- a/src/utils/onlyChild.js
+++ b/src/utils/onlyChild.js
@@ -1,4 +1,18 @@
 /**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
  * @providesModule onlyChild
  */
 "use strict";

From 6a41ede2d426cea1cb29103305362383f4d10f4d Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 17 Jun 2013 12:47:39 -0700
Subject: [PATCH 19/94] Fixing known keying problems

This fixes the last known parts of the flattening experiment. This has grown to
be somewhat complex and potentially fragile because of it. We may end up
reverting flattening in the future or address it slightly differently.

The purpose of this diff is to test if we've finally understood the real world
edge cases that flattening can lead to and how we have to key components to
cover those cases.

With this commit we never rekey the internal _key property. The semantics is
that once a component passes through a composite component, it's identity is
frozen.

props.key should accept numeric values and booleans which includes 0 and false.
This fixes the truthiness check.

We should never warn about missing key properties if a component is passed as a
static child. The _key acts as a flag to determine whether this component
was checked already.
---
 src/core/ReactComponent.js                    |  68 +++++++++--
 src/core/ReactCompositeComponent.js           |   4 +
 src/core/ReactCurrentOwner.js                 |  14 ++-
 .../ReactComponentFlattenChildren-test.js     |  45 +++----
 src/core/__tests__/ReactIdentity-test.js      | 114 +++++++++++++++---
 src/utils/__tests__/mapChildren-test.js       |  15 +--
 6 files changed, 203 insertions(+), 57 deletions(-)

diff --git a/src/core/ReactComponent.js b/src/core/ReactComponent.js
index f7ff79b245..8e7a64ad9e 100644
--- a/src/core/ReactComponent.js
+++ b/src/core/ReactComponent.js
@@ -66,37 +66,84 @@ var HAS_WARNED = false;
  * one.
  */
 
+/**
+ * Generate a unique key that identifies this child within a set.
+ *
+ * @param {*} Manually provided key.
+ * @param {number} Index that is used if a manual key is not provided.
+ * @param {?number} Grouping index if this is used in a nested array.
+ * @return {string}
+ */
+function createKey(explicitKey, childIndex, groupingIndex) {
+  return ReactCurrentOwner.getDepth() + ':' +
+         (groupingIndex == null ? '' : groupingIndex + ':') +
+         (explicitKey == null ? '' + childIndex : explicitKey);
+}
+
+/**
+ * Returns true if this parameter type is considered an empty child slot.
+ * Used to filter out empty slots and generate a compact array.
+ *
+ * @param {*} Child component or any value.
+ * @return {boolean}
+ */
 function isEmptyChild(child) {
   return child == null || typeof child === 'boolean';
 }
 
-function assignKey(setKey, child, index) {
-  if (ReactComponent.isValidComponent(child)) {
+/**
+ * Assign an internal identity to a child component.
+ *
+ * @param {number} Index of the current array grouping.
+ * @param {*} Child component or any value.
+ * @param {number} Index of the current child within it's grouping.
+ */
+function assignKey(groupingIndex, child, index) {
+  // Only truthy internal keys are valid. If it's not, we assign one.
+  if (ReactComponent.isValidComponent(child) && !child._key) {
     var key = child.props.key;
     if (__DEV__) {
-      if (!HAS_WARNED && !key) {
+      // This is in an array. This could grow and shrink or be reordered.
+      // All children that doesn't already have autogenerated identity needs
+      // to have an explicit key provided.
+      if (!HAS_WARNED && key == null) {
         HAS_WARNED = true;
         console && console.warn && console.warn(CHILD_HAS_NO_IDENTITY);
       }
     }
-    child._key = (setKey ? setKey + ':' : '') + (key || ('' + index));
+    child._key = createKey(key, index, groupingIndex);
   }
 }
 
+/**
+ * Make sure all children have an internal identity. Returns true if this is
+ * already a compact array.
+ *
+ * @param {array} Children of any type.
+ * @return {boolean}
+ */
 function tryToReuseArray(children) {
   for (var i = 0; i < children.length; i++) {
     var child = children[i];
     if (isEmptyChild(child)) return false;
-    assignKey('0', child, i);
+    assignKey(0, child, i);
   }
   return true;
 }
 
-function appendNestedChildren(parentKey, sourceArray, targetArray) {
+/**
+ * Append children from the source array to the target array. Make sure all
+ * children have an internal identity assigned to it based on insertion point.
+ *
+ * @param {number} Index of the current array grouping.
+ * @param {array} Source array.
+ * @param {array} Target array that will be appended to.
+ */
+function appendNestedChildren(groupingIndex, sourceArray, targetArray) {
   for (var i = 0; i < sourceArray.length; i++) {
     var child = sourceArray[i];
     if (isEmptyChild(child)) continue;
-    assignKey(parentKey, child, i);
+    assignKey(groupingIndex, child, i);
     // TODO: Invalid components like strings could possibly need
     // keys assigned to them here. Usually they're not stateful but
     // CSS transitions and special events could make them stateful.
@@ -294,14 +341,15 @@ var ReactComponent = {
           if (child.length === 0) continue;
 
           if (targetArray === null) targetArray = [];
-          appendNestedChildren('' + (i - 1), child, targetArray);
+          appendNestedChildren(i - 1, child, targetArray);
 
         } else if (!isEmptyChild(child)) {
 
-          if (ReactComponent.isValidComponent(child)) {
+          // Only truthy internal keys are valid. If it's not, we assign one.
+          if (ReactComponent.isValidComponent(child) && !child._key) {
             // This is a static node and therefore safe to key by index.
             // No warning necessary.
-            child._key = child.props.key || ('' + (i - 1));
+            child._key = createKey(child.props.key, i - 1);
           }
 
           if (targetArray === null) targetArray = [];
diff --git a/src/core/ReactCompositeComponent.js b/src/core/ReactCompositeComponent.js
index ac2e57d93c..6e79b9ca97 100644
--- a/src/core/ReactCompositeComponent.js
+++ b/src/core/ReactCompositeComponent.js
@@ -414,6 +414,8 @@ var ReactCompositeComponentMixin = {
     this.state = null;
     this._pendingState = null;
     this._compositeLifeCycleState = null;
+    this._compositionLevel = ReactCurrentOwner.current ?
+      ReactCurrentOwner.getDepth() + 1 : 0;
   },
 
   /**
@@ -453,6 +455,8 @@ var ReactCompositeComponentMixin = {
 
     this._renderedComponent = this._renderValidatedComponent();
 
+    this._renderedComponent._compositionLevel = this._compositionLevel + 1;
+
     // Done with mounting, `setState` will now trigger UI changes.
     this._compositeLifeCycleState = null;
     this._lifeCycleState = ReactComponent.LifeCycle.MOUNTED;
diff --git a/src/core/ReactCurrentOwner.js b/src/core/ReactCurrentOwner.js
index 819071ff75..4a6b96ef96 100644
--- a/src/core/ReactCurrentOwner.js
+++ b/src/core/ReactCurrentOwner.js
@@ -23,6 +23,8 @@
  *
  * The current owner is the component who should own any components that are
  * currently being constructed.
+ *
+ * The depth indicate how many composite components are above this render level.
  */
 var ReactCurrentOwner = {
 
@@ -30,7 +32,17 @@ var ReactCurrentOwner = {
    * @internal
    * @type {ReactComponent}
    */
-  current: null
+  current: null,
+
+  /**
+   * @internal
+   * @return {number}
+   */
+  getDepth: function() {
+    var owner = ReactCurrentOwner.current;
+    if (!owner) return 0;
+    return owner._compositionLevel;
+  }
 
 };
 
diff --git a/src/core/__tests__/ReactComponentFlattenChildren-test.js b/src/core/__tests__/ReactComponentFlattenChildren-test.js
index 972172c541..9ebe7baa2a 100644
--- a/src/core/__tests__/ReactComponentFlattenChildren-test.js
+++ b/src/core/__tests__/ReactComponentFlattenChildren-test.js
@@ -56,8 +56,8 @@ describe('ReactComponentFlatten', function() {
     var flat = singleChild(children);
 
     expect(flat).toBe(children);
-    expect(flat[0]._key).toEqual('0:foo');
-    expect(flat[1]._key).toEqual('0:bar');
+    expect(flat[0]._key).toEqual('0:0:foo');
+    expect(flat[1]._key).toEqual('0:0:bar');
   });
 
   it("should collapse a sparse array", function() {
@@ -71,8 +71,8 @@ describe('ReactComponentFlatten', function() {
 
     expect(flat).not.toBe(children);
     expect(flat.length).toEqual(2);
-    expect(flat[0]._key).toEqual('0:foo');
-    expect(flat[1]._key).toEqual('0:bar');
+    expect(flat[0]._key).toEqual('0:0:foo');
+    expect(flat[1]._key).toEqual('0:0:bar');
   });
 
   it("should collapse a nested array into a flat array", function() {
@@ -83,13 +83,11 @@ describe('ReactComponentFlatten', function() {
     );
 
     expect(flat.length).toEqual(2);
-    expect(flat[0]._key).toEqual('foo');
-    expect(flat[1]._key).toEqual('2:bar');
+    expect(flat[0]._key).toEqual('0:foo');
+    expect(flat[1]._key).toEqual('0:2:bar');
   });
 
-  it("should use retain key index despite static empty values", function() {
-    // TODO: Wrap in another single child (currently breaks)
-
+  it("should retain key index despite static empty values", function() {
     var before = multiChild(
       <div />,
       <div />,
@@ -110,22 +108,25 @@ describe('ReactComponentFlatten', function() {
     expect(before[3]._key).toEqual(after[1]._key);
   });
 
-  it("should assign idempotent keys for extra flattening layers", function() {
-    var flat = multiChild(
-      null,
-      [null, <div key="FOO" />],
-      false
-    );
+  it("should retain key index when wrapped", function() {
+    var before = singleChild(multiChild(
+      <div />,
+      <div />,
+      [<div key="foo" />],
+      [<div key="foo" />]
+    ));
 
-    var preFlat = multiChild(
+    var after = singleChild(multiChild(
       null,
-      singleChild([null, <div key="FOO" />]),
-      false
-    );
+      <div />,
+      null,
+      [<div key="foo" />]
+    ));
 
-    expect(flat.length).toBe(1);
-    expect(preFlat.length).toBe(1);
-    expect(preFlat[0]._key).toBe(flat[0]._key);
+    expect(before.length).toEqual(4);
+    expect(after.length).toEqual(2);
+    expect(before[1]._key).toEqual(after[0]._key);
+    expect(before[3]._key).toEqual(after[1]._key);
   });
 
   it("should assign idempotent strings through flattening", function() {
diff --git a/src/core/__tests__/ReactIdentity-test.js b/src/core/__tests__/ReactIdentity-test.js
index ee3f88487f..f92a4c3e0b 100644
--- a/src/core/__tests__/ReactIdentity-test.js
+++ b/src/core/__tests__/ReactIdentity-test.js
@@ -62,13 +62,17 @@ describe('ReactIdentity', function() {
       <div>
         <div key="apple" />
         <div key="banana" />
+        <div key={0} />
+        <div key={123} />
       </div>;
 
     React.renderComponent(instance, document.createElement('div'));
     var node = instance.getDOMNode();
-    reactComponentExpect(instance).toBeDOMComponentWithChildCount(2);
-    checkId(node.childNodes[0], '.reactRoot[0].[apple]');
-    checkId(node.childNodes[1], '.reactRoot[0].[banana]');
+    reactComponentExpect(instance).toBeDOMComponentWithChildCount(4);
+    checkId(node.childNodes[0], '.reactRoot[0].[0:apple]');
+    checkId(node.childNodes[1], '.reactRoot[0].[0:banana]');
+    checkId(node.childNodes[2], '.reactRoot[0].[0:0]');
+    checkId(node.childNodes[3], '.reactRoot[0].[0:123]');
   });
 
   it('should use instance identity', function() {
@@ -89,32 +93,108 @@ describe('ReactIdentity', function() {
     React.renderComponent(instance, document.createElement('div'));
     var node = instance.getDOMNode();
     reactComponentExpect(instance).toBeDOMComponentWithChildCount(3);
-    checkId(node.childNodes[0], '.reactRoot[0].[wrap1]');
+    checkId(node.childNodes[0], '.reactRoot[0].[0:wrap1]');
     checkId(
       node.childNodes[0].firstChild,
-      '.reactRoot[0].[wrap1].[0:squirrel]'
+      '.reactRoot[0].[0:wrap1].[0:squirrel]'
     );
-    checkId(node.childNodes[1], '.reactRoot[0].[wrap2]');
-    checkId(node.childNodes[1].firstChild, '.reactRoot[0].[wrap2].[0:bunny]');
-    checkId(node.childNodes[2], '.reactRoot[0].[2]');
-    checkId(node.childNodes[2].firstChild, '.reactRoot[0].[2].[0:chipmunk]');
+    checkId(node.childNodes[1], '.reactRoot[0].[0:wrap2]');
+    checkId(node.childNodes[1].firstChild, '.reactRoot[0].[0:wrap2].[0:bunny]');
+    checkId(node.childNodes[2], '.reactRoot[0].[0:2]');
+    checkId(node.childNodes[2].firstChild, '.reactRoot[0].[0:2].[0:chipmunk]');
   });
 
   it('should let restructured components retain their uniqueness', function() {
     var instance0 = <span />;
     var instance1 = <span />;
     var instance2 = <span />;
-    var wrapped = <div>{instance0} {instance1}</div>;
-    var unwrappedAndAdded =
-      <div>
-        {instance2}
-        {wrapped.props.children[0]}
-        {wrapped.props.children[1]}
-      </div>;
+
+    var TestComponent = React.createClass({
+      render: function() {
+        return (
+          <div>
+            {instance2}
+            {this.props.children[0]}
+            {this.props.children[1]}
+          </div>
+        );
+      }
+    });
+
+    var TestContainer = React.createClass({
+
+      render: function() {
+        return <TestComponent>{instance0} {instance1}</TestComponent>;
+      }
+
+    });
 
     expect(function() {
 
-      React.renderComponent(unwrappedAndAdded, document.createElement('div'));
+      React.renderComponent(<TestContainer />, document.createElement('div'));
+
+    }).not.toThrow();
+  });
+
+  it('should let nested restructures retain their uniqueness', function() {
+    var instance0 = <span />;
+    var instance1 = <span />;
+    var instance2 = <span />;
+
+    var TestComponent = React.createClass({
+      render: function() {
+        return (
+          <div>
+            {instance2}
+            {this.props.children[0]}
+            {this.props.children[1]}
+          </div>
+        );
+      }
+    });
+
+    var TestContainer = React.createClass({
+
+      render: function() {
+        return (
+          <div>
+            <TestComponent>{instance0} {instance1}</TestComponent>
+          </div>
+        );
+      }
+
+    });
+
+    expect(function() {
+
+      React.renderComponent(<TestContainer />, document.createElement('div'));
+
+    }).not.toThrow();
+  });
+
+  it('should let text nodes retain their uniqueness', function() {
+    var TestComponent = React.createClass({
+      render: function() {
+        return <div>{this.props.children}<span /></div>;
+      }
+    });
+
+    var TestContainer = React.createClass({
+
+      render: function() {
+        return (
+          <TestComponent>
+            <div />
+            {'second'}
+          </TestComponent>
+        );
+      }
+
+    });
+
+    expect(function() {
+
+      React.renderComponent(<TestContainer />, document.createElement('div'));
 
     }).not.toThrow();
   });
diff --git a/src/utils/__tests__/mapChildren-test.js b/src/utils/__tests__/mapChildren-test.js
index 39f557f38e..8376d28f5a 100644
--- a/src/utils/__tests__/mapChildren-test.js
+++ b/src/utils/__tests__/mapChildren-test.js
@@ -73,7 +73,7 @@ describe('mapChildren', function() {
       .expectRenderedChild()
       .instance();
 
-    expect(mapFn).toHaveBeenCalledWith(simpleKid, 'simple', 0);
+    expect(mapFn).toHaveBeenCalledWith(simpleKid, '0:simple', 0);
     expect(rendered.props.children[0]).toBe(simpleKid);
     expect(rendered.props.children).toHaveKeys(['0:simple']);
   });
@@ -94,8 +94,9 @@ describe('mapChildren', function() {
 
     expect(rendered.props.children[0]).not.toBe(simpleKid);
     expect(rendered.props.children[0].props.children[0]).toBe(simpleKid);
-    expect(rendered.props.children).toHaveKeys(['0:simple']);
-    expect(rendered.props.children[0].props.children).toHaveKeys(['simple']);
+    expect(rendered.props.children).toHaveKeys(['0:0:0:simple']);
+    expect(rendered.props.children[0].props.children)
+      .toHaveKeys(['0:simple']);
   });
 
   it('should be called for each child', function() {
@@ -122,12 +123,12 @@ describe('mapChildren', function() {
       .instance();
 
     expect(mapFn.calls.length).toBe(3);
-    expect(mapFn).toHaveBeenCalledWith(kidOne, 'one', 0);
-    expect(mapFn).toHaveBeenCalledWith(kidTwo, 'two', 1);
-    expect(mapFn).toHaveBeenCalledWith(kidThree, 'three', 2);
+    expect(mapFn).toHaveBeenCalledWith(kidOne, '0:one', 0);
+    expect(mapFn).toHaveBeenCalledWith(kidTwo, '0:two', 1);
+    expect(mapFn).toHaveBeenCalledWith(kidThree, '0:three', 2);
     expect(rendered.props.children).not.toEqual(instance.props.children);
     expect(rendered.props.children).toHaveKeys([
-      '0:one', '0:two', '0:three'
+      '0:0:0:one', '0:0:0:two', '0:0:0:three'
     ]);
   });
 });

From d8b6d260c965c154d3a1997e613597a50c140656 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 17 Jun 2013 12:47:43 -0700
Subject: [PATCH 20/94] Add missing license header

---
 src/utils/__tests__/onlyChild-test.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/utils/__tests__/onlyChild-test.js b/src/utils/__tests__/onlyChild-test.js
index 9c0c51febc..840a014386 100644
--- a/src/utils/__tests__/onlyChild-test.js
+++ b/src/utils/__tests__/onlyChild-test.js
@@ -1,4 +1,18 @@
 /**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
  * @emails react-core
  * @jsx React.DOM
  */

From 2383fd8813a83b27f7bc895d19146952cc32c62b Mon Sep 17 00:00:00 2001
From: Ben Newman <bn@cs.stanford.edu>
Date: Mon, 17 Jun 2013 15:55:54 -0400
Subject: [PATCH 21/94] Upgrade Recast to 0.4.8 to fix options.writeback bug.

Bug introduced by: https://github.com/benjamn/recast/commit/e913b22f8f
Bug fixed by: https://github.com/benjamn/recast/commit/170e18091e
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 0333bb02cd..de72afeec9 100644
--- a/package.json
+++ b/package.json
@@ -38,7 +38,7 @@
     "base62": "~0.1.1",
     "commoner": "~0.7.0",
     "esprima": "git://github.com/facebook/esprima#fb-harmony",
-    "recast": "~0.4.5",
+    "recast": "~0.4.8",
     "source-map": "~0.1.22"
   },
   "devDependencies": {

From 0f87e8ee87c37ce677d7c87c297e51b7f4694d88 Mon Sep 17 00:00:00 2001
From: Ben Newman <bn@cs.stanford.edu>
Date: Mon, 17 Jun 2013 16:21:51 -0400
Subject: [PATCH 22/94] Rename Woodchipper-related stuff.

No functional changes introduced by this commit.

Renamed:

    woodchipper.js -> constants.js
    Woodchipper -> ConstantVisitor
    debranch -> propagate
---
 bin/jsx                                 | 9 ++++-----
 vendor/{woodchipper.js => constants.js} | 8 ++++----
 2 files changed, 8 insertions(+), 9 deletions(-)
 rename vendor/{woodchipper.js => constants.js} (86%)

diff --git a/bin/jsx b/bin/jsx
index ccdb19e668..c6aa70e8ec 100755
--- a/bin/jsx
+++ b/bin/jsx
@@ -3,7 +3,7 @@
 
 var visitors = require('../vendor/fbtransform/visitors').transformVisitors;
 var transform = require('../vendor/fbtransform/lib/transform').transform;
-var debranch = require("../vendor/woodchipper").debranch;
+var propagate = require("../vendor/constants").propagate;
 
 require("commoner").resolve(function(id) {
   var context = this;
@@ -32,10 +32,9 @@ require("commoner").resolve(function(id) {
   return context.makePromise(function(callback) {
     var constants = context.config.constants || {};
 
-    // Debranching means removing any obviously dead code after
-    // replacing constant conditional expressions with literal
-    // (boolean) values.
-    debranch(constants, source, function(source) {
+    // Constant propagation means removing dead code after replacing
+    // constant conditional expressions with literal (boolean) values.
+    propagate(constants, source, function(source) {
       callback(null, source);
     });
   });
diff --git a/vendor/woodchipper.js b/vendor/constants.js
similarity index 86%
rename from vendor/woodchipper.js
rename to vendor/constants.js
index 5330d446f1..c5f178f3a1 100644
--- a/vendor/woodchipper.js
+++ b/vendor/constants.js
@@ -17,17 +17,17 @@
 
 var recast = require('recast');
 
-exports.debranch = function(constants, source, writeback) {
+exports.propagate = function(constants, source, writeback) {
   recast.runString(
     source,
     function(ast, callback) {
-      callback(new Woodchipper(constants).visit(ast));
+      callback(new ConstantVisitor(constants).visit(ast));
     },
     { writeback: writeback }
   );
 };
 
-var Woodchipper = recast.Visitor.extend({
+var ConstantVisitor = recast.Visitor.extend({
   init: function(constants) {
     this.constants = constants || {};
   },
@@ -57,6 +57,6 @@ var Woodchipper = recast.Visitor.extend({
 if (!module.parent) {
   var constants = JSON.parse(process.argv[3]);
   recast.run(function(ast, callback) {
-    callback(new Woodchipper(constants).visit(ast));
+    callback(new ConstantVisitor(constants).visit(ast));
   });
 }

From 000928f9dc8c44457814170a9e8642ae157c0d51 Mon Sep 17 00:00:00 2001
From: Ben Newman <bn@cs.stanford.edu>
Date: Mon, 17 Jun 2013 16:27:02 -0400
Subject: [PATCH 23/94] Use recast.parse and .print for
 require("vendor/constants").propagate.

This removes the need to pass a callback, which is a nice improvement.
---
 bin/jsx             | 13 ++++---------
 vendor/constants.js | 12 ++++--------
 2 files changed, 8 insertions(+), 17 deletions(-)

diff --git a/bin/jsx b/bin/jsx
index c6aa70e8ec..2a6437d535 100755
--- a/bin/jsx
+++ b/bin/jsx
@@ -25,17 +25,12 @@ require("commoner").resolve(function(id) {
 
 }).process(function(id, source) {
   var context = this;
+  var constants = context.config.constants || {};
 
   // This is where JSX, ES6, etc. desugaring happens.
   source = transform(visitors.react, source).code;
 
-  return context.makePromise(function(callback) {
-    var constants = context.config.constants || {};
-
-    // Constant propagation means removing dead code after replacing
-    // constant conditional expressions with literal (boolean) values.
-    propagate(constants, source, function(source) {
-      callback(null, source);
-    });
-  });
+  // Constant propagation means removing any obviously dead code after
+  // replacing constant expressions with literal (boolean) values.
+  return propagate(constants, source);
 });
diff --git a/vendor/constants.js b/vendor/constants.js
index c5f178f3a1..b0530b4d69 100644
--- a/vendor/constants.js
+++ b/vendor/constants.js
@@ -17,14 +17,10 @@
 
 var recast = require('recast');
 
-exports.propagate = function(constants, source, writeback) {
-  recast.runString(
-    source,
-    function(ast, callback) {
-      callback(new ConstantVisitor(constants).visit(ast));
-    },
-    { writeback: writeback }
-  );
+exports.propagate = function(constants, source) {
+  var ast = recast.parse(source);
+  ast = new ConstantVisitor(constants).visit(ast);
+  return recast.print(ast);
 };
 
 var ConstantVisitor = recast.Visitor.extend({

From 4a0456fb8e41e54d9c6ebf4ff0d7f942d7aa27f9 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 17 Jun 2013 16:24:58 -0700
Subject: [PATCH 24/94] Fix lint warning about mismatched file & module name

@providesModule should match the file name. In this case we'll be consistent and suffix mixins with Mixin.
---
 src/core/ReactComponentWithPureRenderMixin.js | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/core/ReactComponentWithPureRenderMixin.js b/src/core/ReactComponentWithPureRenderMixin.js
index 7f46ed42fb..1ac4c23aad 100644
--- a/src/core/ReactComponentWithPureRenderMixin.js
+++ b/src/core/ReactComponentWithPureRenderMixin.js
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
-* @providesModule ReactComponentWithPureRender
+* @providesModule ReactComponentWithPureRenderMixin
 */
 
 "use strict";
@@ -27,9 +27,10 @@
  *
  * Example:
  *
- *   var ReactComponentWithPureRender = require('ReactComponentWithPureRender');
+ *   var ReactComponentWithPureRender =
+ *     require('ReactComponentWithPureRenderMixin');
  *   React.createClass({
- *     mixins: [ReactComponentWithPureRender],
+ *     mixins: [ReactComponentWithPureRenderMixin],
  *
  *     render: function() {
  *       return <div className={this.props.className}>foo</div>;
@@ -41,7 +42,7 @@
  * differences. Only mixin to components which have simple props and state, or
  * use `forceUpdate()` when you know deep data structures have changed.
  */
-var ReactComponentWithPureRender = {
+var ReactComponentWithPureRenderMixin = {
   shouldComponentUpdate: function(nextProps, nextState) {
     return !shallowEqual(this.props, nextProps) ||
            !shallowEqual(this.state, nextState);
@@ -74,4 +75,4 @@ function shallowEqual(objA, objB) {
   return true;
 }
 
-module.exports = ReactComponentWithPureRender;
+module.exports = ReactComponentWithPureRenderMixin;

From 48333acba657ac98b5760f89c22e48a8b4be27ac Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 17 Jun 2013 16:25:02 -0700
Subject: [PATCH 25/94] Remove reactKeys

It wasn't being used and it wasn't conforming to the @providesModule === file name rule.
---
 src/utils/keys.js | 34 ----------------------------------
 1 file changed, 34 deletions(-)
 delete mode 100644 src/utils/keys.js

diff --git a/src/utils/keys.js b/src/utils/keys.js
deleted file mode 100644
index 271e7f1d64..0000000000
--- a/src/utils/keys.js
+++ /dev/null
@@ -1,34 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule reactKeys
- */
-
-"use strict";
-
-/**
- * Similar to Object.keys() but does not fail on empty parameter.
- */
-var keys = function(obj) {
-  var ret = [], aKey;
-  for (aKey in obj) {
-    if (obj.hasOwnProperty(aKey)) {
-      ret.push(aKey);
-    }
-  }
-  return ret;
-};
-
-module.exports = keys;

From 315645804133e190e23be954787f5d64144d33d5 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 17 Jun 2013 16:25:08 -0700
Subject: [PATCH 26/94] Fix most lint warnings/errors

---
 src/core/ReactComponent.js                    | 22 ++++++++++++----
 src/core/ReactCurrentOwner.js                 |  4 ++-
 src/core/__tests__/ReactDOM-test.js           | 25 +++++++++++--------
 .../__tests__/ReactInstanceHandles-test.js    |  2 --
 .../__tests__/ReactMountDestruction-test.js   |  5 ----
 .../__tests__/ReactMultiChildText-test.js     |  7 +++---
 src/core/__tests__/ReactProps-test.js         |  2 +-
 src/dom/DOMChildrenOperations.js              |  3 +++
 src/dom/Danger.js                             |  2 ++
 .../__tests__/CSSPropertyOperations-test.js   |  2 ++
 src/dom/getEventTarget.js                     |  2 ++
 .../__tests__/ReactServerRendering-test.js    |  4 ++-
 src/event/synthetic/SyntheticEvent.js         |  2 ++
 src/event/synthetic/SyntheticFocusEvent.js    |  2 ++
 src/event/synthetic/SyntheticKeyboardEvent.js |  2 ++
 src/event/synthetic/SyntheticMouseEvent.js    |  2 ++
 src/event/synthetic/SyntheticMutationEvent.js |  2 ++
 src/event/synthetic/SyntheticTouchEvent.js    |  2 ++
 src/event/synthetic/SyntheticUIEvent.js       |  2 ++
 src/event/synthetic/SyntheticWheelEvent.js    |  2 ++
 src/eventPlugins/EnterLeaveEventPlugin.js     |  5 ++--
 src/utils/__tests__/ImmutableObject-test.js   |  5 +---
 src/utils/mergeDeepInto.js                    |  3 +++
 23 files changed, 75 insertions(+), 34 deletions(-)

diff --git a/src/core/ReactComponent.js b/src/core/ReactComponent.js
index 8e7a64ad9e..67b4e90207 100644
--- a/src/core/ReactComponent.js
+++ b/src/core/ReactComponent.js
@@ -16,6 +16,8 @@
  * @providesModule ReactComponent
  */
 
+/*jslint evil: true */
+
 "use strict";
 
 var ReactCurrentOwner = require('ReactCurrentOwner');
@@ -125,7 +127,9 @@ function assignKey(groupingIndex, child, index) {
 function tryToReuseArray(children) {
   for (var i = 0; i < children.length; i++) {
     var child = children[i];
-    if (isEmptyChild(child)) return false;
+    if (isEmptyChild(child)) {
+      return false;
+    }
     assignKey(0, child, i);
   }
   return true;
@@ -142,7 +146,9 @@ function tryToReuseArray(children) {
 function appendNestedChildren(groupingIndex, sourceArray, targetArray) {
   for (var i = 0; i < sourceArray.length; i++) {
     var child = sourceArray[i];
-    if (isEmptyChild(child)) continue;
+    if (isEmptyChild(child)) {
+      continue;
+    }
     assignKey(groupingIndex, child, i);
     // TODO: Invalid components like strings could possibly need
     // keys assigned to them here. Usually they're not stateful but
@@ -338,9 +344,13 @@ var ReactComponent = {
       for (var i = 1; i < arguments.length; i++) {
         var child = arguments[i];
         if (Array.isArray(child)) {
-          if (child.length === 0) continue;
+          if (child.length === 0) {
+            continue;
+          }
 
-          if (targetArray === null) targetArray = [];
+          if (targetArray === null) {
+            targetArray = [];
+          }
           appendNestedChildren(i - 1, child, targetArray);
 
         } else if (!isEmptyChild(child)) {
@@ -352,7 +362,9 @@ var ReactComponent = {
             child._key = createKey(child.props.key, i - 1);
           }
 
-          if (targetArray === null) targetArray = [];
+          if (targetArray === null) {
+            targetArray = [];
+          }
           targetArray.push(child);
 
         }
diff --git a/src/core/ReactCurrentOwner.js b/src/core/ReactCurrentOwner.js
index 4a6b96ef96..9ac0ab6ede 100644
--- a/src/core/ReactCurrentOwner.js
+++ b/src/core/ReactCurrentOwner.js
@@ -40,7 +40,9 @@ var ReactCurrentOwner = {
    */
   getDepth: function() {
     var owner = ReactCurrentOwner.current;
-    if (!owner) return 0;
+    if (!owner) {
+      return 0;
+    }
     return owner._compositionLevel;
   }
 
diff --git a/src/core/__tests__/ReactDOM-test.js b/src/core/__tests__/ReactDOM-test.js
index f327b147b9..3d20fd6e16 100644
--- a/src/core/__tests__/ReactDOM-test.js
+++ b/src/core/__tests__/ReactDOM-test.js
@@ -17,6 +17,8 @@
  * @emails react-core
  */
 
+/*jslint evil: true */
+
 "use strict";
 
 var React = require('React');
@@ -81,27 +83,30 @@ describe('ref swapping', function() {
         theBird: <div class="bird" />
       }}</div>
     );
+    // Warm the cache with theDog
     myDiv.setProps({
       children: {
-        theDog: <div class="dogbeforedelete" />,  // Warm the cache with theDog
+        theDog: <div class="dogbeforedelete" />,
         theBird: <div class="bird" />
       }
     });
-    myDiv.setProps({
-      children: {                                 // This better purge that cache
-        theBird: <div class="bird" />
-      }
-    });
-    // Now, put the dog back.
+    // Remove theDog - this should purge the cache
     myDiv.setProps({
       children: {
-        theDog: <div class="dog" />,       // This is a different node than before
         theBird: <div class="bird" />
       }
     });
+    // Now, put theDog back. It's now a different DOM node.
     myDiv.setProps({
-      children: {                          // className changed to bigdog.
-        theDog: <div class="bigdog" />,    // but will it use the proper element
+      children: {
+        theDog: <div class="dog" />,
+        theBird: <div class="bird" />
+      }
+    });
+    // Change the className of theDog. It will use the same element
+    myDiv.setProps({
+      children: {
+        theDog: <div class="bigdog" />,
         theBird: <div class="bird" />
       }
     });
diff --git a/src/core/__tests__/ReactInstanceHandles-test.js b/src/core/__tests__/ReactInstanceHandles-test.js
index 4c7b227381..95e03d8250 100644
--- a/src/core/__tests__/ReactInstanceHandles-test.js
+++ b/src/core/__tests__/ReactInstanceHandles-test.js
@@ -22,8 +22,6 @@
 var React = require('React');
 var ReactTestUtils = require('ReactTestUtils');
 
-var reactComponentExpect= require('reactComponentExpect');
-
 /**
  * Ensure that all callbacks are invoked, passing this unique argument.
  */
diff --git a/src/core/__tests__/ReactMountDestruction-test.js b/src/core/__tests__/ReactMountDestruction-test.js
index 6a993ea680..2654dfc632 100644
--- a/src/core/__tests__/ReactMountDestruction-test.js
+++ b/src/core/__tests__/ReactMountDestruction-test.js
@@ -19,12 +19,7 @@
 
 "use strict";
 
-var ReactMount = require('ReactMount');
 var React = require('React');
-var ReactTestUtils = require('ReactTestUtils');
-var ReactMount = require('ReactMount');
-
-var reactComponentExpect = require('reactComponentExpect');
 
 describe('ReactMount', function() {
   it("should destroy a react root upon request", function() {
diff --git a/src/core/__tests__/ReactMultiChildText-test.js b/src/core/__tests__/ReactMultiChildText-test.js
index 85195a5176..a842d89e14 100644
--- a/src/core/__tests__/ReactMultiChildText-test.js
+++ b/src/core/__tests__/ReactMultiChildText-test.js
@@ -17,13 +17,14 @@
  * @emails react-core
  */
 
+/*jslint evil: true */
+
 "use strict";
 
 require('mock-modules');
 
 var React = require('React');
 var ReactTestUtils = require('ReactTestUtils');
-var ReactTextComponent = require('ReactTextComponent');
 
 var reactComponentExpect = require('reactComponentExpect');
 
@@ -141,7 +142,7 @@ describe('ReactMultiChildText', function() {
     assertMultiChild(d, 'hello', 'goodbye');
   });
 
-  it('should render zero string as text node  then switch to spans', function() {
+  it('should render zero string as text node then switch to spans', function() {
     var d = renderSingleTextChild('0');
     // false should act exactly as a null child
     assertNodeText(d, '0');
@@ -149,7 +150,7 @@ describe('ReactMultiChildText', function() {
     assertMultiChild(d, 'hello', 'goodbye');
   });
 
-  it('should render zero number as text node  then switch to spans', function() {
+  it('should render zero number as text node then switch to spans', function() {
     var d = renderSingleTextChild('0');
     // false should act exactly as a null child
     assertNodeText(d, 0);
diff --git a/src/core/__tests__/ReactProps-test.js b/src/core/__tests__/ReactProps-test.js
index 82cb58ebee..df9080ae3e 100644
--- a/src/core/__tests__/ReactProps-test.js
+++ b/src/core/__tests__/ReactProps-test.js
@@ -26,7 +26,7 @@ function typeCheck(declaration, value) {
   if (arguments.length > 1) {
     props.testProp = value;
   }
-  return declaration.bind(this, props, 'testProp', 'testComponent');
+  return declaration.bind(null, props, 'testProp', 'testComponent');
 }
 
 describe('Primitive Types', function() {
diff --git a/src/dom/DOMChildrenOperations.js b/src/dom/DOMChildrenOperations.js
index f1fd2fc85f..ce0f762a39 100644
--- a/src/dom/DOMChildrenOperations.js
+++ b/src/dom/DOMChildrenOperations.js
@@ -16,6 +16,9 @@
  * @providesModule DOMChildrenOperations
  */
 
+// Empty blocks improve readability so disable that warning
+// jshint -W035
+
 "use strict";
 
 var Danger = require('Danger');
diff --git a/src/dom/Danger.js b/src/dom/Danger.js
index 0117e2ef5e..1181739679 100644
--- a/src/dom/Danger.js
+++ b/src/dom/Danger.js
@@ -16,6 +16,8 @@
  * @providesModule Danger
  */
 
+/*jslint evil: true */
+
 "use strict";
 
 var ExecutionEnvironment = require('ExecutionEnvironment');
diff --git a/src/dom/__tests__/CSSPropertyOperations-test.js b/src/dom/__tests__/CSSPropertyOperations-test.js
index 3918d801af..2164c38e9f 100644
--- a/src/dom/__tests__/CSSPropertyOperations-test.js
+++ b/src/dom/__tests__/CSSPropertyOperations-test.js
@@ -17,6 +17,8 @@
  * @emails react-core
  */
 
+/*jslint evil: true */
+
 "use strict";
 
 var React = require('React');
diff --git a/src/dom/getEventTarget.js b/src/dom/getEventTarget.js
index 9529e3932f..7cb4ce3eb7 100644
--- a/src/dom/getEventTarget.js
+++ b/src/dom/getEventTarget.js
@@ -17,6 +17,8 @@
  * @typechecks
  */
 
+"use strict";
+
 var ExecutionEnvironment = require('ExecutionEnvironment');
 
 /**
diff --git a/src/environment/__tests__/ReactServerRendering-test.js b/src/environment/__tests__/ReactServerRendering-test.js
index 779730a68f..ebbad6b4b0 100644
--- a/src/environment/__tests__/ReactServerRendering-test.js
+++ b/src/environment/__tests__/ReactServerRendering-test.js
@@ -17,6 +17,8 @@
  * @emails react-core
  */
 
+/*jslint evil: true */
+
 "use strict";
 
 require('mock-modules')
@@ -147,7 +149,7 @@ describe('ReactServerRendering', function() {
         return (
           <span ref="span" onClick={this.click}>Name: {this.props.name}</span>
         );
-      },
+      }
     });
 
     var element = document.createElement('div');
diff --git a/src/event/synthetic/SyntheticEvent.js b/src/event/synthetic/SyntheticEvent.js
index c72275f679..366da3cbc6 100644
--- a/src/event/synthetic/SyntheticEvent.js
+++ b/src/event/synthetic/SyntheticEvent.js
@@ -17,6 +17,8 @@
  * @typechecks
  */
 
+"use strict";
+
 var PooledClass = require('PooledClass');
 
 var emptyFunction = require('emptyFunction');
diff --git a/src/event/synthetic/SyntheticFocusEvent.js b/src/event/synthetic/SyntheticFocusEvent.js
index 8ba8e73c5c..a90ba3f79a 100644
--- a/src/event/synthetic/SyntheticFocusEvent.js
+++ b/src/event/synthetic/SyntheticFocusEvent.js
@@ -17,6 +17,8 @@
  * @typechecks
  */
 
+"use strict";
+
 var SyntheticUIEvent = require('SyntheticUIEvent');
 
 /**
diff --git a/src/event/synthetic/SyntheticKeyboardEvent.js b/src/event/synthetic/SyntheticKeyboardEvent.js
index 64448c91f9..6e6b078282 100644
--- a/src/event/synthetic/SyntheticKeyboardEvent.js
+++ b/src/event/synthetic/SyntheticKeyboardEvent.js
@@ -17,6 +17,8 @@
  * @typechecks
  */
 
+"use strict";
+
 var SyntheticUIEvent = require('SyntheticUIEvent');
 
 /**
diff --git a/src/event/synthetic/SyntheticMouseEvent.js b/src/event/synthetic/SyntheticMouseEvent.js
index fa3fed1c23..6272fbb83a 100644
--- a/src/event/synthetic/SyntheticMouseEvent.js
+++ b/src/event/synthetic/SyntheticMouseEvent.js
@@ -17,6 +17,8 @@
  * @typechecks
  */
 
+"use strict";
+
 var BrowserEnv = require('BrowserEnv');
 var SyntheticUIEvent = require('SyntheticUIEvent');
 
diff --git a/src/event/synthetic/SyntheticMutationEvent.js b/src/event/synthetic/SyntheticMutationEvent.js
index 84fcbf187b..55ae1baa35 100644
--- a/src/event/synthetic/SyntheticMutationEvent.js
+++ b/src/event/synthetic/SyntheticMutationEvent.js
@@ -17,6 +17,8 @@
  * @typechecks
  */
 
+"use strict";
+
 var SyntheticEvent = require('SyntheticEvent');
 
 /**
diff --git a/src/event/synthetic/SyntheticTouchEvent.js b/src/event/synthetic/SyntheticTouchEvent.js
index ccc4fe89d1..304e592608 100644
--- a/src/event/synthetic/SyntheticTouchEvent.js
+++ b/src/event/synthetic/SyntheticTouchEvent.js
@@ -17,6 +17,8 @@
  * @typechecks
  */
 
+"use strict";
+
 var SyntheticUIEvent = require('SyntheticUIEvent');
 
 /**
diff --git a/src/event/synthetic/SyntheticUIEvent.js b/src/event/synthetic/SyntheticUIEvent.js
index 314d9d81b1..4e2b0d5964 100644
--- a/src/event/synthetic/SyntheticUIEvent.js
+++ b/src/event/synthetic/SyntheticUIEvent.js
@@ -17,6 +17,8 @@
  * @typechecks
  */
 
+"use strict";
+
 var SyntheticEvent = require('SyntheticEvent');
 
 /**
diff --git a/src/event/synthetic/SyntheticWheelEvent.js b/src/event/synthetic/SyntheticWheelEvent.js
index 857c8eaa9f..bab71dd4ba 100644
--- a/src/event/synthetic/SyntheticWheelEvent.js
+++ b/src/event/synthetic/SyntheticWheelEvent.js
@@ -17,6 +17,8 @@
  * @typechecks
  */
 
+"use strict";
+
 var SyntheticMouseEvent = require('SyntheticMouseEvent');
 
 /**
diff --git a/src/eventPlugins/EnterLeaveEventPlugin.js b/src/eventPlugins/EnterLeaveEventPlugin.js
index e4967e91dd..c3fe3a8fe7 100644
--- a/src/eventPlugins/EnterLeaveEventPlugin.js
+++ b/src/eventPlugins/EnterLeaveEventPlugin.js
@@ -72,8 +72,9 @@ var EnterLeaveEventPlugin = {
     var from, to;
     if (topLevelType === topLevelTypes.topMouseOut) {
       from = topLevelTarget;
-      to = getFirstReactDOM(nativeEvent.relatedTarget || nativeEvent.toElement)
-        || ExecutionEnvironment.global;
+      to =
+        getFirstReactDOM(nativeEvent.relatedTarget || nativeEvent.toElement) ||
+        ExecutionEnvironment.global;
     } else {
       from = ExecutionEnvironment.global;
       to = topLevelTarget;
diff --git a/src/utils/__tests__/ImmutableObject-test.js b/src/utils/__tests__/ImmutableObject-test.js
index fbcda924ae..3b9bae72cb 100644
--- a/src/utils/__tests__/ImmutableObject-test.js
+++ b/src/utils/__tests__/ImmutableObject-test.js
@@ -23,9 +23,6 @@ require('mock-modules')
 
 var ImmutableObject;
 
-var expectSeriallyEqual = function(one, two) {
-};
-
 /**
  * To perform performance testing of using `ImmutableObject` vs. not using
  * `ImmutableObject`, such testing must be done with __DEV__ set to false.
@@ -270,7 +267,7 @@ describe('ImmutableObject', function() {
     });
     expect(afterIO).toBeSeriallyEqualTo({
       a: {b: {}, c: 'C', d: 'd', e: {f: 'F', g: 'G'}, h: 'H'}
-    })
+    });
     expect(afterIO).not.toBe(beforeIO);
     expect(afterIO.a).not.toBe(beforeIO.a);
     expect(afterIO.a.e).not.toBe(beforeIO.a.e);
diff --git a/src/utils/mergeDeepInto.js b/src/utils/mergeDeepInto.js
index daa637624d..36131bb320 100644
--- a/src/utils/mergeDeepInto.js
+++ b/src/utils/mergeDeepInto.js
@@ -16,6 +16,9 @@
  * @providesModule mergeDeepInto
  */
 
+// Empty blocks improve readability so disable that warning
+// jshint -W035
+
 "use strict";
 
 var keyMirror = require('keyMirror');

From a0475b3c292790a666ee69dfb416ba0e5b66be07 Mon Sep 17 00:00:00 2001
From: Zach Bruggeman <zbruggeman@me.com>
Date: Mon, 17 Jun 2013 16:27:07 -0700
Subject: [PATCH 27/94] Fix package.json's reference to vendor/constants.js

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index de72afeec9..1973a38791 100644
--- a/package.json
+++ b/package.json
@@ -21,7 +21,7 @@
     "bin/jsx",
     "build/modules/",
     "vendor/fbtransform/",
-    "vendor/woodchipper.js"
+    "vendor/constants.js"
   ],
   "main": "main.js",
   "bin": {

From 5bd449c157a377dc2dc66d6b737de019c6f1e98a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Paul=20O=E2=80=99Shannessy?= <paul@oshannessy.com>
Date: Mon, 17 Jun 2013 17:14:14 -0700
Subject: [PATCH 28/94] Ignore .module-cache directories

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index b7e395980c..090d7c3aee 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,11 +6,13 @@ static
 .grunt
 _SpecRunner.html
 build/
+.module-cache
 *.gem
 docs/code
 docs/_site
 docs/.sass-cache
 docs/css/react.css
+docs/js/.module-cache
 docs/js/JSXTransformer.js
 docs/js/react.min.js
 docs/js/docs.js

From 37ddfa0521d07c7066998704119ffaa249fa6aa8 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Tue, 18 Jun 2013 09:31:39 -0700
Subject: [PATCH 29/94] Don't transfer `children` in `transferPropsTo`

06cff60bc1eec13ff804af9f74b3b2b37b5490b3 made it so that `this.props.children` was no longer set when
none were provided.

  var x = <div />;

This caused an issue if the code was relying on the following not
transferring children.

  return this.transferPropsTo(<div />);
  // this now transfer children
---
 src/core/ReactPropTransferer.js               |  8 ++++--
 ...actCompositeComponentTransferProps-test.js | 25 ++++++++++++++++---
 2 files changed, 28 insertions(+), 5 deletions(-)

diff --git a/src/core/ReactPropTransferer.js b/src/core/ReactPropTransferer.js
index c1f697af4e..691ed58fc8 100644
--- a/src/core/ReactPropTransferer.js
+++ b/src/core/ReactPropTransferer.js
@@ -44,13 +44,17 @@ function createTransferStrategy(mergeStrategy) {
  */
 var TransferStrategies = {
   /**
-   * Never transfer the `ref` prop.
+   * Never transfer `children`.
    */
-  ref: emptyFunction,
+  children: emptyFunction,
   /**
    * Transfer the `className` prop by merging them.
    */
   className: createTransferStrategy(joinClasses),
+  /**
+   * Never transfer the `ref` prop.
+   */
+  ref: emptyFunction,
   /**
    * Transfer the `style` prop (which is an object) by merging them.
    */
diff --git a/src/core/__tests__/ReactCompositeComponentTransferProps-test.js b/src/core/__tests__/ReactCompositeComponentTransferProps-test.js
index e32660801f..47cc7455af 100644
--- a/src/core/__tests__/ReactCompositeComponentTransferProps-test.js
+++ b/src/core/__tests__/ReactCompositeComponentTransferProps-test.js
@@ -51,7 +51,7 @@ describe('ReactCompositeComponent-transferProps', function() {
     ReactTestUtils.renderIntoDocument(instance);
 
     reactComponentExpect(instance)
-      .expectRenderedChild(instance)
+      .expectRenderedChild()
         .toBeDOMComponentWithTag('input')
         .scalarPropsEqual({
           className: 'textinput',
@@ -66,7 +66,7 @@ describe('ReactCompositeComponent-transferProps', function() {
     ReactTestUtils.renderIntoDocument(instance);
 
     reactComponentExpect(instance)
-      .expectRenderedChild(instance)
+      .expectRenderedChild()
         .toBeDOMComponentWithTag('input')
         .scalarPropsEqual({placeholder: 'Type here...'});
   });
@@ -80,7 +80,7 @@ describe('ReactCompositeComponent-transferProps', function() {
     ReactTestUtils.renderIntoDocument(instance);
 
     reactComponentExpect(instance)
-      .expectRenderedChild(instance)
+      .expectRenderedChild()
         .toBeDOMComponentWithTag('input')
         .scalarPropsEqual({
           className: 'textinput hidden_elem',
@@ -91,6 +91,25 @@ describe('ReactCompositeComponent-transferProps', function() {
         });
   });
 
+  it('should not transfer children', function() {
+    var ChildrenTestComponent = React.createClass({
+      render: function() {
+        return this.transferPropsTo(<div />);
+      }
+    });
+
+    var instance =
+      <ChildrenTestComponent>
+        <span>Hello!</span>
+      </ChildrenTestComponent>;
+
+    ReactTestUtils.renderIntoDocument(instance);
+    reactComponentExpect(instance)
+      .expectRenderedChild()
+        .toBeDOMComponentWithTag('div')
+        .toBeDOMComponentWithNoChildren();
+  });
+
   it('should not transfer ref', function() {
     var RefTestComponent = React.createClass({
       render: function() {

From 0e91febb9ce8eb6eac3154a6e4b06cfcc16115ab Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Tue, 18 Jun 2013 09:31:42 -0700
Subject: [PATCH 30/94] Better warnings for missing keys on arrays

We have less dynamic arrays in the code base now so let's start warning for all
the cases where we pass dynamic arrays without keys.

I use the displayName to point out which component's render method was
responsible. I only warn once per component. If the child was created in a
different component (and passed as a property) I also show the owner of the
child. Maybe it should've attached the key at a higher level.

This does give false positives for arrays that are truly static. Those should
probably be refactored to use the XML syntax if possible.
---
 src/core/ReactComponent.js | 33 +++++++++++++++++++++++++++------
 1 file changed, 27 insertions(+), 6 deletions(-)

diff --git a/src/core/ReactComponent.js b/src/core/ReactComponent.js
index 67b4e90207..530a6f9c66 100644
--- a/src/core/ReactComponent.js
+++ b/src/core/ReactComponent.js
@@ -58,10 +58,12 @@ var ComponentLifeCycle = keyMirror({
  */
 
 var CHILD_HAS_NO_IDENTITY =
-    'You are passing a dynamic array of children. You should set the ' +
-    'property "key" to a string that uniquely identifies each child.';
+  'Each child in an array should have a unique "key" prop. ' +
+  'Check the render method of ';
 
-var HAS_WARNED = false;
+var CHILD_CAME_FROM_ANOTHER_OWNER = '. It was passed a child from ';
+
+var owner_has_warned = {};
 
 /**
  * Helpers for flattening child arguments onto a new array or use an existing
@@ -108,9 +110,28 @@ function assignKey(groupingIndex, child, index) {
       // This is in an array. This could grow and shrink or be reordered.
       // All children that doesn't already have autogenerated identity needs
       // to have an explicit key provided.
-      if (!HAS_WARNED && key == null) {
-        HAS_WARNED = true;
-        console && console.warn && console.warn(CHILD_HAS_NO_IDENTITY);
+      if (key == null) {
+        // Name of the component whose render method tried to pass children.
+        var currentName =
+          ReactCurrentOwner.current &&
+          ReactCurrentOwner.current.constructor.displayName;
+
+        // Name of the component that originally created this child.
+        var childOwnerName =
+          child.props[OWNER] && child.props[OWNER].constructor.displayName;
+
+        if (currentName && !owner_has_warned.hasOwnProperty(currentName)) {
+          owner_has_warned[currentName] = true;
+          var message = CHILD_HAS_NO_IDENTITY + currentName;
+          if (childOwnerName && currentName !== childOwnerName) {
+            // Usually the current owner is the offender, but if it accepts
+            // children as a property, it may be the creator of the child that's
+            // responsible for assigning it a key.
+            message += CHILD_CAME_FROM_ANOTHER_OWNER + childOwnerName;
+          }
+          message += '.';
+          console && console.warn && console.warn(message);
+        }
       }
     }
     child._key = createKey(key, index, groupingIndex);

From 870a29d9b0a154ebc31dcc08cb1121ba3594639a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Paul=20O=E2=80=99Shannessy?= <paul@oshannessy.com>
Date: Tue, 18 Jun 2013 10:20:34 -0700
Subject: [PATCH 31/94] Use absolute URLs for FB comments box

---
 docs/_layouts/docs.html | 2 +-
 docs/_layouts/post.html | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/_layouts/docs.html b/docs/_layouts/docs.html
index 8df307908b..ff0b835ac3 100644
--- a/docs/_layouts/docs.html
+++ b/docs/_layouts/docs.html
@@ -20,6 +20,6 @@ sectionid: docs
       {% endif %}
     </div>
 
-    <div class="fb-comments" data-width="650" data-num-posts="10" data-href="/react{{ page.url }}"></div>
+    <div class="fb-comments" data-width="650" data-num-posts="10" data-href="{{ site.url }}{{ site.baseurl }}{{ page.url }}"></div>
   </div>
 </section>
diff --git a/docs/_layouts/post.html b/docs/_layouts/post.html
index 656085dcb6..9aa96b3565 100644
--- a/docs/_layouts/post.html
+++ b/docs/_layouts/post.html
@@ -16,6 +16,6 @@ sectionid: blog
     </div>
 
     <div class="fb-like" data-send="true" data-width="650" data-show-faces="false"></div>
-    <div class="fb-comments" data-width="650" data-num-posts="10" data-href="/react{{ page.url }}"></div>
+    <div class="fb-comments" data-width="650" data-num-posts="10" data-href="{{ site.url }}{{ site.baseurl }}{{ page.url }}"></div>
   </div>
 </section>

From bd044fc919b46d9d8d495e162598e6499f70e64b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Paul=20O=E2=80=99Shannessy?= <paul@oshannessy.com>
Date: Tue, 18 Jun 2013 15:29:37 -0700
Subject: [PATCH 32/94] Use github tarball link for esprima dependency

It turns out that (at least for local development) npm has a long
standing bug where it doesn't recognize changing dependencies stored as
git urls (see https://github.com/isaacs/npm/issues/1727). Luckily npm
understand tarballs and GitHub provides tarballs for every commit, so
the workaround is easy, though unfortunate.
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 1973a38791..7b59fa79f8 100644
--- a/package.json
+++ b/package.json
@@ -37,7 +37,7 @@
   "dependencies": {
     "base62": "~0.1.1",
     "commoner": "~0.7.0",
-    "esprima": "git://github.com/facebook/esprima#fb-harmony",
+    "esprima": "https://github.com/facebook/esprima/tarball/ca28795124d45968e62a7b4b336d23a053ac3a84",
     "recast": "~0.4.8",
     "source-map": "~0.1.22"
   },

From ea5e13893e320f640c2061ce8e09729d44ad23a9 Mon Sep 17 00:00:00 2001
From: Christopher Chedeau <vjeuxx@gmail.com>
Date: Wed, 19 Jun 2013 00:09:02 -0600
Subject: [PATCH 33/94] Fix dangerouslySetInnerHTML

---
 docs/docs/jsx-is-not-html.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/docs/jsx-is-not-html.md b/docs/docs/jsx-is-not-html.md
index 084c97197b..b248c2c9f2 100644
--- a/docs/docs/jsx-is-not-html.md
+++ b/docs/docs/jsx-is-not-html.md
@@ -55,7 +55,7 @@ You can use mixed arrays with strings and JSX elements.
 As a last resort, you always have the ability to insert raw HTML.
 
 ```javascript
-<div dangerouslySetInnerHTML={{__html: 'First &middot; Second'}} />
+<div dangerouslySetInnerHTML={{'{{'}}__html: 'First &middot; Second'}} />
 ```
 
 ## Comments

From 0493b27222bd8da9b724b46200bf393c120b1ec9 Mon Sep 17 00:00:00 2001
From: Ben Alpert <spicyjalapeno@gmail.com>
Date: Thu, 13 Jun 2013 20:27:36 -0700
Subject: [PATCH 34/94] Don't update value or textContent unnecessarily

_updateDOMChildren was already updating textContent so we don't need to
do it in _updateDOMProperties. Additionally, don't update .value if
it'll be a noop because it has side-effects (like moving the cursor) in
some browsers (like IE 9).

Refactor tests to be a bit more robust and a bit cleaner too.
---
 src/core/ReactDOMTextarea.js                | 47 ++++++++++-----
 src/core/ReactNativeComponent.js            | 10 ++--
 src/core/__tests__/ReactDOMTextarea-test.js | 63 ++++++++++++++-------
 3 files changed, 78 insertions(+), 42 deletions(-)

diff --git a/src/core/ReactDOMTextarea.js b/src/core/ReactDOMTextarea.js
index f484da01cb..a9f22e0b65 100644
--- a/src/core/ReactDOMTextarea.js
+++ b/src/core/ReactDOMTextarea.js
@@ -30,8 +30,34 @@ var textarea = ReactDOM.textarea;
 var CONTENT_TYPES = {'string': true, 'number': true};
 
 var getTextContent = function(props) {
-  return props.content != null ? '' + props.content :
-    CONTENT_TYPES[typeof props.children] ? '' + props.children : '';
+  if (!props) {
+    return '';
+  }
+
+  invariant(
+    props.dangerouslySetInnerHTML == null,
+    '`dangerouslySetInnerHTML` does not make sense on textarea.'
+  );
+
+  var content;
+  if (Array.isArray(props.children)) {
+    invariant(
+      props.children.length <= 1,
+      'textarea can have at most one child'
+    );
+    content = props.children[0];
+  } else if (props.children != null) {
+    content = props.children;
+  } else {
+    content = props.content;
+  }
+
+  invariant(
+    content == null || CONTENT_TYPES[typeof content],
+    'textarea must contain a single string or number, not an array or ' +
+    'object.'
+  );
+  return content != null ? '' + content : '';
 };
 
 /**
@@ -40,33 +66,24 @@ var getTextContent = function(props) {
  */
 var ReactDOMTextarea = ReactCompositeComponent.createClass({
   getInitialState: function() {
-    // We keep the original value of content and children here so that
+    // We keep the original value of content or children here so that
     // ReactNativeComponent doesn't update textContent (unnecessary since we
     // update value).
     return {
-      initialContent: this.props.content,
-      initialChildren: this.props.children
+      initialContent: getTextContent(this.props)
     };
   },
 
   render: function() {
-    invariant(
-      this.props.dangerouslySetInnerHTML == null,
-      '`dangerouslySetInnerHTML` does not make sense on textarea.'
-    );
-    invariant(
-      this.props.children == null || CONTENT_TYPES[typeof this.props.children],
-      'When present, textarea children must be a single string or number.'
-    );
     return this.transferPropsTo(textarea({
       content: this.state.initialContent
-    }, this.state.initialChildren));
+    }));
   },
 
   componentDidUpdate: function(prevProps, prevState, rootNode) {
     var oldContent = getTextContent(prevProps);
     var newContent = getTextContent(this.props);
-    if (oldContent !== newContent) {
+    if (oldContent !== newContent && rootNode.value !== newContent) {
       rootNode.value = newContent;
     }
   }
diff --git a/src/core/ReactNativeComponent.js b/src/core/ReactNativeComponent.js
index 07371b2c8f..91f63ae71d 100644
--- a/src/core/ReactNativeComponent.js
+++ b/src/core/ReactNativeComponent.js
@@ -219,12 +219,13 @@ ReactNativeComponent.Mixin = {
             styleUpdates[styleName] = '';
           }
         }
-      } else if (propKey === DANGEROUSLY_SET_INNER_HTML ||
-                 propKey === CONTENT) {
+      } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
         ReactComponent.DOMIDOperations.updateTextContentByID(
           this._rootNodeID,
           ''
         );
+      } else if (propKey === CONTENT) {
+        // (Removal happens in _updateDOMChildren)
       } else if (registrationNames[propKey]) {
         deleteListener(this._rootNodeID, propKey);
       } else {
@@ -275,10 +276,7 @@ ReactNativeComponent.Mixin = {
           );
         }
       } else if (propKey === CONTENT) {
-        ReactComponent.DOMIDOperations.updateTextContentByID(
-          this._rootNodeID,
-          '' + nextProp
-        );
+        // (Update happens in _updateDOMChildren)
       } else if (registrationNames[propKey]) {
         putListener(this._rootNodeID, propKey, nextProp);
       } else {
diff --git a/src/core/__tests__/ReactDOMTextarea-test.js b/src/core/__tests__/ReactDOMTextarea-test.js
index 1fb6d97820..0e600625c6 100644
--- a/src/core/__tests__/ReactDOMTextarea-test.js
+++ b/src/core/__tests__/ReactDOMTextarea-test.js
@@ -19,45 +19,66 @@
 
 "use strict";
 
+var mocks = require('mocks');
+
 describe('ReactDOMTextarea', function() {
   var React;
   var ReactTestUtils;
-  var transaction;
+  var getTextContentAccessor;
 
   beforeEach(function() {
     React = require('React');
     ReactTestUtils = require('ReactTestUtils');
+    getTextContentAccessor = require('getTextContentAccessor');
   });
 
-  it("should remove value with removed children", function() {
+  it("should update value and not update textContent", function() {
+    var textContentAccessor = getTextContentAccessor();
     var stub = ReactTestUtils.renderIntoDocument(<textarea>giraffe</textarea>);
+    var node = stub.getDOMNode();
 
-    expect(stub.getDOMNode().value).toEqual('giraffe');
-    stub.replaceProps({ children: null });
-    expect(stub.getDOMNode().value).toEqual('');
-  });
+    var nodeText = node[textContentAccessor];
+    var nodeTextSetter = mocks.getMockFunction();
+    Object.defineProperty(node, textContentAccessor, {
+      get: function() {
+        return nodeText;
+      },
+      set: nodeTextSetter.mockImplementation(function(newText) {
+        nodeText = newText;
+      })
+    });
 
-  it("should update value with a single string child", function() {
-    var stub = ReactTestUtils.renderIntoDocument(<textarea>monkey</textarea>);
+    expect(node.value).toEqual('giraffe');
 
-    expect(stub.getDOMNode().value).toEqual('monkey');
     stub.replaceProps({ children: 'gorilla' });
-    expect(stub.getDOMNode().value).toEqual('gorilla');
-  });
+    expect(node.value).toEqual('gorilla');
 
-  it("should update value with a single numerical child", function() {
-    var stub = ReactTestUtils.renderIntoDocument(<textarea>17</textarea>);
+    stub.replaceProps({ children: 17 });
+    expect(node.value).toEqual('17');
 
-    expect(stub.getDOMNode().value).toEqual('17');
-    stub.replaceProps({ children: 289 });
-    expect(stub.getDOMNode().value).toEqual('289');
-  });
+    stub.replaceProps({ children: [42] });
+    expect(node.value).toEqual('42');
 
-  it("should update value with the content property", function() {
-    var stub = ReactTestUtils.renderIntoDocument(<textarea content="purple" />);
+    stub.replaceProps({ children: null });
+    expect(node.value).toEqual('');
 
-    expect(stub.getDOMNode().value).toEqual('purple');
     stub.replaceProps({ content: 'eggplant' });
-    expect(stub.getDOMNode().value).toEqual('eggplant');
+    expect(node.value).toEqual('eggplant');
+
+    expect(nodeTextSetter.mock.calls.length).toBe(0);
+  });
+
+  it("should throw with multiple or invalid children", function() {
+    expect(function() {
+      var stub = ReactTestUtils.renderIntoDocument(
+        <textarea>{'hello'}{'there'}</textarea>
+      );
+    }).toThrow();
+
+    expect(function() {
+      var stub = ReactTestUtils.renderIntoDocument(
+        <textarea><strong /></textarea>
+      );
+    }).toThrow();
   });
 });

From cb01363260b6e43981c286cac9818a13dc1e6a91 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Paul=20O=E2=80=99Shannessy?= <paul@oshannessy.com>
Date: Fri, 7 Jun 2013 15:35:42 -0700
Subject: [PATCH 35/94] Cleanup lint warnings

---
 grunt/tasks/npm.js     | 5 ++---
 grunt/tasks/phantom.js | 2 +-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/grunt/tasks/npm.js b/grunt/tasks/npm.js
index becc96a894..8fe6b7ad32 100644
--- a/grunt/tasks/npm.js
+++ b/grunt/tasks/npm.js
@@ -2,13 +2,11 @@
 
 var assert = require("assert");
 var path = require("path");
-var fs = require("fs");
 var tmp = require("tmp");
 var grunt = require("grunt");
 var spawn = grunt.util.spawn;
 
 module.exports = function() {
-  var config = this.data;
   var done = this.async();
 
   function run(cmd, args, opts, callback) {
@@ -25,7 +23,8 @@ module.exports = function() {
 
     grunt.log.writeln("> " + cmd + " " + args.join(" "));
 
-    var proc = spawn({
+    // var proc =
+    spawn({
       cmd: cmd,
       args: args,
       opts: opts
diff --git a/grunt/tasks/phantom.js b/grunt/tasks/phantom.js
index ff71f683c6..d5c66eb258 100644
--- a/grunt/tasks/phantom.js
+++ b/grunt/tasks/phantom.js
@@ -38,7 +38,7 @@ function run(config, done) {
   }
 
   args.push("--tests");
-  var tests = grunt.file.expand({
+  grunt.file.expand({
     nonull: true,
     cwd: "src"
   }, config.tests || []).forEach(function(file) {

From 32030687bacda1da4952ada7710956600960902c Mon Sep 17 00:00:00 2001
From: Vjeux <vjeuxx@gmail.com>
Date: Wed, 19 Jun 2013 19:39:11 +0200
Subject: [PATCH 36/94] Community Roundup #2

---
 docs/_posts/2013-06-19-community-roundup-2.md |  71 ++++++++++++++++++
 docs/docs/jsx-is-not-html.md                  |   2 +-
 docs/img/blog/chatapp.png                     | Bin 0 -> 27896 bytes
 docs/img/blog/todomvc.png                     | Bin 0 -> 52203 bytes
 docs/img/blog/xreact.png                      | Bin 0 -> 7913 bytes
 5 files changed, 72 insertions(+), 1 deletion(-)
 create mode 100644 docs/_posts/2013-06-19-community-roundup-2.md
 create mode 100644 docs/img/blog/chatapp.png
 create mode 100644 docs/img/blog/todomvc.png
 create mode 100644 docs/img/blog/xreact.png

diff --git a/docs/_posts/2013-06-19-community-roundup-2.md b/docs/_posts/2013-06-19-community-roundup-2.md
new file mode 100644
index 0000000000..57b322e1cc
--- /dev/null
+++ b/docs/_posts/2013-06-19-community-roundup-2.md
@@ -0,0 +1,71 @@
+---
+title: "Community Round-up #2"
+layout: post
+author: Vjeux
+---
+
+Since the launch we have received a lot of feedback and are actively working on React 0.4. In the meantime, here are the highlights of this week.
+
+## Some quick thoughts on React
+
+[Andrew Greig](http://www.andrewgreig.com/) made a blog post that gives a high level description of what React is.
+
+> I have been using Facebooks recently released Javascript framework called React.js for the last few days and have managed to obtain a rather high level understanding of how it works and formed a good perspective on how it fits in to the entire javascript framework ecosystem.
+>
+> Basically, React is not an MVC framework. It is not a replacement for Backbone or Knockout or Angular, instead it is designed to work with existing frameworks and help extend their functionality.
+>
+> It is designed for building big UIs. The type where you have lots of reusable components that are handling events and presenting and changing some backend data. In a traditional MVC app, React fulfils the role of the View. So you would still need to handle the Model and Controller on your own.
+>
+> I found the best way to utilise React was to pair it with Backbone, with React replacing the Backbone View, or to write your own Model/Data object and have React communicate with that.
+>
+> [Read the full post...](http://www.andrewgreig.com/637/)
+
+## React and Socket.IO Chat Application
+
+[Danial Khosravi](http://danialk.github.io/) made a real-time chat application that interacts with the back-end using Socket.IO.
+
+> A week ago I was playing with AngularJS and [this little chat application](https://github.com/btford/angular-socket-io-im) which uses socket.io and nodejs for realtime communication. Yesterday I saw a post about ReactJS in [EchoJS](http://www.echojs.com/) and started playing with this UI library. After playing a bit with React, I decided to write and chat application using React and I used Bran Ford's Backend for server side of this little app.
+> <figure>[![](/react/img/blog/chatapp.png)](http://danialk.github.io/blog/2013/06/16/reactjs-and-socket-dot-io-chat-application/)</figure>
+>
+> [Read the full post...](http://danialk.github.io/blog/2013/06/16/reactjs-and-socket-dot-io-chat-application/)
+
+## React and Other Frameworks
+
+[Pete Hunt](http://www.petehunt.net/blog/) wrote an answer on Quora comparing React and Angular directives. At the end, he explains how you can make an Angular directive that is in fact being rendered with React.
+
+> To set the record straight: React components are far more powerful than Angular templates; they should be compared with Angular's directives instead. So I took the first Google hit for "AngularJS directive tutorial" (AngularJS Directives Tutorial - Fundoo Solutions), rewrote it in React and compared them. [...]
+>
+> We've designed React from the beginning to work well with other libraries. Angular is no exception. Let's take the original Angular example and use React to implement the fundoo-rating directive.
+>
+> [Read the full post...](http://www.quora.com/Pete-Hunt/Posts/Facebooks-React-vs-AngularJS-A-Closer-Look)
+
+In the same vein, [Markov Twain](https://twitter.com/markov_twain/status/345702941845499906) re-implemented the examples on the front-page [with Ember](http://jsbin.com/azihiw/2/edit) and [Vlad Yazhbin](https://twitter.com/vla) re-implemented the tutorial [with Angular](http://jsfiddle.net/vla/Cdrse/).
+
+## Web Components: React & x-tags
+
+Mozilla and Google are actively working on Web Components. [Vjeux](http://blog.vjeux.com/) wrote a proof of concept that shows how to implement them using React.
+
+> Using [x-tags](http://www.x-tags.org/) from Mozilla, we can write custom tags within the DOM. This is a great opportunity to be able to write reusable components without being tied to a particular library. I wrote [x-react](https://github.com/vjeux/react-xtags/) to have them being rendered in React.
+> <figure>[![](/react/img/blog/xreact.png)](http://blog.vjeux.com/2013/javascript/custom-components-react-x-tags.html)</figure>
+>
+> [Read the full post...](http://blog.vjeux.com/2013/javascript/custom-components-react-x-tags.html)
+
+## React TodoMVC Example
+
+[TodoMVC.com](http://todomvc.com/) is a website that collects various implementations of the same basic Todo app. [Pete Hunt](http://www.petehunt.net/blog/) wrote an idiomatic React version.
+
+> Developers these days are spoiled with choice when it comes to selecting an MV* framework for structuring and organizing their JavaScript web apps.
+>
+> To help solve this problem, we created TodoMVC - a project which offers the same Todo application implemented using MV* concepts in most of the popular JavaScript MV* frameworks of today.
+> <figure>[![](/react/img/blog/todomvc.png)](http://todomvc.com/labs/architecture-examples/react/)</figure>
+>
+> [Read the source code...](https://github.com/tastejs/todomvc/tree/gh-pages/labs/architecture-examples/react)
+
+## JSX is not HTML
+
+Many of you pointed out differences between JSX and HTML. In order to clear up some confusion, we have added some documentation that covers the four main differences:
+
+  - [Whitespace removal](http://facebook.github.io/react/docs/jsx-is-not-html.html)
+  - [HTML Entities](http://facebook.github.io/react/docs/jsx-is-not-html.html)
+  - [Comments](http://facebook.github.io/react/docs/jsx-is-not-html.html)
+  - [Custom HTML Attributes](http://facebook.github.io/react/docs/jsx-is-not-html.html)
diff --git a/docs/docs/jsx-is-not-html.md b/docs/docs/jsx-is-not-html.md
index 084c97197b..e8d0d7bac6 100644
--- a/docs/docs/jsx-is-not-html.md
+++ b/docs/docs/jsx-is-not-html.md
@@ -80,7 +80,7 @@ As of React 0.3, there is no good way to insert comments within the children sec
 </div>
 ```
 
-## Custom HTML attributes
+## Custom HTML Attributes
 
 If you pass properties to native HTML elements that do not exist in the HTML specification, React will not render them. If you want to use a custom attribute, you should prefix it with `data-`.
 
diff --git a/docs/img/blog/chatapp.png b/docs/img/blog/chatapp.png
new file mode 100644
index 0000000000000000000000000000000000000000..55edf29dd0675f5ce9f0e02ccf744d3a9fa26bc7
GIT binary patch
literal 27896
zcmV*7Kytr{P)<h;3K|Lk000e1NJLTq00FrG005>40ssI2$iZfX00001b5ch_0Itp)
z=>Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>DY>i1oK~#8N?Y-NV
zUd44UN~_hnBS2ul8yRfl*y>Meb+@`(7bI~pagZTgi~(bkoP7*9A@LqIf($MW7<)e$
z69PE#f%ug%fHTf}{F>*CvET9+oq4I6HRr5Zwbs|&y4l|tKeg7XRjV$ue)X$awbrWd
zy6cXfWb8P0N{$6{^mo3xwD-h0_`7iYv<@7Dxy5yTy0A2L3VT;E>oJ&{Z0OTn%lGJ0
z!T1CL^HG6!E}iD^FQ0!1{w_>P9d{i+1AliOJGDRujNL0|<(MrjSXeTq-l2}S0&XwH
zf%W_3n4!zF2|)E-h;G&yuf|};s~T4wulT<mM^p2+NVZcQvk9P)xJ>&_oR>?0o!lxa
z52=-FKZXw6t!X#e04ngYRDRFOS=TFScuO5wgTG<cTgSXUoos}Rui-iyfX%*dRdK6|
zGX_x2O%MXW_E|WVI-!`$w1|R4U~BJQiKESUwK>dqbv5$JoOCg_xVC@oUKa?^Ed-oP
z$076j?WC^mTQl`>D7iGi5xk*u`e1_F&p)IG<N;7!xPy&x7LxTF&<$YhNx4WTaU;Kp
zsSK6MGt|!+z!Dy-x$d<iP{RqtfYC@krp1g`@OQ>5ed=+Q@XDNI@F3tIdFWQD{p6`C
zCd11X-E}}csMgRWzkcI>_$$WJGbv80*s)G|ac$S~aF@{8$*`;g1=0=Ncza;|Ud$+}
zT5HG!h~E^>Qye5tYp7?mW^G}0T9IeGg1<9fX<SRZa_1(k5iBWj@`0bK3<2XW>f%m5
zc<;Io9*d0yaC3njRUun9B8lzj!T0tjU(h_9pd`zk!GXJk8y=0bKzRvoT7_hAEBIcT
zt#qL499<r8O;cM?IrVXkt?_E*wYRVP!+VTFubs0o8>o1dFvP1Te(>?9zx(vP)4Grs
z-umUI5cugY-*}<~X3TiCjkvtL!h<RF%AZHzAtDrShfw(S++j~+)KYDnv{EjG;Kf?)
zW7lgsjyIhFv$g6m9vzOdO$L|49Ht#|MxiRh$c3;3%f(&NtYbJDVQOBTyZbYxl~eL+
z1TMVwE6~JuU$VS<64X<x<cwDy*E+8(n!GAURKs{JW^tVtM8l*95vmxq8Ombz7q0v4
z`4zfaX{9q+U_pP2Vi>t3Z{NLCLJ(>BMv|g~okurH1@omndR;tYZn9qUgR$f229Mj0
z<#cN5TbF7xfV`v@h{=b_6oVZpSSFi5`PXZ29e{x@JWAhI9IO1{<KuZ1QX<1@Wt&%c
zJj_*BmkD~5-gBflr{4Yar_bZ5YttH6h*y^YkeAegprz+3;1%L>>s30h>M;M}e|__v
zFZA=cJ+J=v9WVam`t^ISd;CAX`Tl=r{Ko+@;{4GMzV!Zof9dg`9DIkv|LfrSa&G|S
z{dIr1IFXR0b4Dwlx|sV+j<e&j!_tfX@ZRC4D6mA!NJ_yqf?F;g{(w7Jsw1n3^hxP^
zoNpcO5iZuSpBqp_Vd3~Ot{R<UMp_G&o<EeUkgA4=s$9iK**&>_U(*yV5F=eWAm4M7
zMJlJve2pngIfXV;HBFrk%s_!xmJ%=>14?KHI;}*s?88YVs9U1&)T5q%52oIy_}Jo(
zH$M60>yM|?s;5Xup2b&Cw`iZmVGFz(cA#2lmKkY)#numM#`>_0XnyYB0z`{q8sQt6
z6!Xf4u(=GcM#7&Lu=b_Xxe1*9#~#k({7>dnSy355KqY>b$e-Nuj?qf}9u|+N*pV(y
z!1}rYNYRs8X-)a<_o>0ot*|4uYk3X2u?WrlF_t-wZ}7}T4ClOZAg8bTbMo(k@Z;?!
z0n*oPUk{u6%^Hv{=gRA#M7dNX94Tu&&MxQP2To?+6O~J<O!2X+S0iWB6b{h+z}l3~
z&5({AwAmDx{=)GSuf1Kgrd3X98duI%c_baMA*ZvPD6!~b8lckMB836${dTd>o4=5J
zDbq(CuX4C5j1~fL9)I_nzn4>hxTtW+`I}pu$#zs@Q@k=5<7xKA7Z7@6BU5H;^WWAj
z9gW@=hz-4`-vIlef?BT-5>x|S%U3^0GW_CyfhN{92WJ!F(6Q21SF)g>$Xe}HDKOE~
zv}KO^UftQSU%h%fpT->$yB6pjXfgJ&)WbRQhmU8j<0aODlt@}FF5w>B4B%`0j@J7t
zeDZ?}CMIJinsM@xloK5yN#E*=DQyAhe%96$U*0lP$fn?|1IueTT@w_0+7=&G&U$33
znugMOF+X@o>0rzTB{I%_-871=oyr%}FFIa8;}iSN{!$S{Jv-)B<_Wk%=wx-=M)MRR
zLLiY1MXq>dU;UX9^T&Kh#H)-^yc)(B+1(tpmpwKYSDjYv+_@Pr&wp_T`I6*6YCrKO
z2Y<m6Z9=V;9i(z}I)>|A$oqUsTqmy+K^=pZ&%+Lh&P&chcXAt9X(bC;vH*so!v)7T
zoKz1ekE{(6rPV?QH&!9*T>hjo6d8+D>V^1{meCTP+%B^ynLu6FPV*7<Tthu@NT#R?
z+zT&-K^%JX0aO+q(n@%xmDUjp(s}J124Wj^EL<8((8`x1SAmUi5WaK2G0vlYEK~cH
zV<6UJCr&INoq79sbzglcjO-*;RI+$swK^wW6#-&&d6m#Aa4TGcN36k^L4hM+1xHvo
zfWAeJ!oh^sC~<-E)emkwc|VzqRwR=?p1hv?O1jr;CELzhkn^5w@Fcey`2neS@#%cg
zO6nEFZ)kGoynxJo_{14}Wvsj=VtWxFWmnS2<!bcrShgtq(T&tRB|OF$zp`4m$yrl(
zRYL_9RZbN@N|gazWqLaV#|(A5M$RI7T}F`mhRK(khMG7f0{y{yLpFYS&4tSO%25s+
z>sRJ<GOy^yObLFH;5kWJ`NqA%D`g*MR4|3d0@Sveufk~#{=eju0dp}Z+gIQG_uu{c
zZ`~z^dw-MLu6_awljt!5Avk#Q0T*HrxwM1m7l7Y78ZP80URe}grI3nO9{TmET7nrp
z=a(S7(ujFQ=<5~!g?}Z*`n60@$#=du_$oS;IT~sr2q>+g6y4mj@)2t#np>F+*cQGx
zmWKC0E|J7(ff9lJfjXNex9TMM6fdcKQS4qh1_znV(rNJ^->Vl5O}I_JU~qZ6%Qh*)
z$vqEz6RQ8gW2wNjerG+V$;O_Q<5J}vwn!Ae)*wJOg>TB2eu_Gto?S>SBpn%__v1=U
zDW}8A3pe|6V%gBot(%4jL*@CAtd=C``WE^nN_<^YLf+g)!>Tzr@#=)w$28fw$y23-
zsxIdyfAyg7s;XoA+0Ln7TbGjx+<(hGRt<u@(XFvHUKOxA*3%K>RVjJBE{V_LtH6R<
zA{2Bj7LK2W#4WGVr5d4h!tLR*W>2paN;HC7^EJF0qgMd@$5AI6^)3MO$Nm>iw}0`u
zcDeUH`G-6K|F46O!#thkvRbcf(<OuCNsxrVkr?{`pYD0`t{nN$YmZUCx;RNzR?kDJ
z^Wa?{eg9tlN&)*jJNQA+#T>tgbsS!kShLnG2_t&7#w<R1GLweNoV$9Gt&FTkrCz1V
zQGDeBJ5!|c6s>fv9Hrx$paAGQML9X^M{Rj19q2;GpT9}MIUSm-V%8-*S2lsQ@~pCO
zn6J#T36g0mJTFk1cZO8&#c;i33DcVToyykQVhh{KE5zXAnobIXN*$m|tyYim5XtV0
zF$Eka)~i!c7njIb%M51i&n-Hm8IXhd(Hrqp8-S3@AQMzl4=kH#xju{)T0(%~A3o+8
zuZzkxm0E-VAD$b&+<0V-7ly!G?o(Mk^wkqLgxcs~bC7o?gpTR7PBxFysX?g~Hq(nn
z;A-U+jVSNF<ieZlm4m&D5jEnBR~)##xU{_DlK_J}7^-crOw$0ySeMk!rBl;B_>*Pq
z9qHx4)LJU#qM`apXuXDwAmfCy6%*guFfE1Tz>)TW26M9s4M^mYewrrLNiX;2!oz{<
zgtE{RcTU08&Z}qm8%Hx4Z-3*cc$J&g^QvIRE5S9%D}KwNA8&6p<6y<@3zlYvpbji1
zu(iG3HkBK`G~{F09eLroUjE=}Qn>Led8nZ>L=Tra4*jj0Di}f`TDA89*mfj+k)R{?
zXlX(0z|cnM`z+%T_wWdRdb~2>idUt#JIr_`xHfpj|Amk9`WUkzib1Aq&}@<9x605V
zw*$<-42knxz;RJlH)L=dfQrV2OfTQ&K!mChC(AL%W<h{kxTtlN52&vZT80Yj+|9jd
zSh8EI!}l@c6=23I7m{$z@e2NdRJ+WenVU6)Bq$Ybo{k$o==8Qw*St_u?R(0jgo*6h
zERz_Z$Hx7<aPA^U;Ja$Cfw4~>?Wv^d!n-lk4aNGQBp~!D1mc5m-TRS4;GD5t@lAeB
zvA7=6V8*K!X1p4OtBqH6uKILZ=n^N7_sH5VWhr){1LS-ifr1BugwC4{P$T?AsbBM`
zntNBz)z#OXL9fSy(Pga)kSg1Sn3|hS-|m3JCY4`q(ODZR=YAWLV6vgh4{+0yCc_9Y
z=IeX`jx7xRoRK4d?zosUUb(;-uXKoG3*)NeRXNH?JI>oefN8)SX6$N^W~woy^*C(L
z>RG6UCUkE=XoK0)0;KPTUk4}ya#v1)A}jZdp|1wUr(!_6mi?w8j8A#@I3tTd48FKK
z2CjQdiy5y3GhS(2GrV$1)GN)G30?9P*l0|8sI4>}?>Be-#{CB(egH?erFC^zX>}VI
z0H=B}A{biRHkl%2n4XNZtwPwlT4T8A0+?3<XS~`3X1vn4>UbqbwM}KnWrx{4Co%(a
zWa6NarfQ6g;6*UCU?kY}#GU2U=n8s-!I=~s;A_k!K1Xn6raICGA?XEX`yzB7T_(9H
zVGUnvN-bOnA4?bfx<7xyZ+F`pgc+a7EPAE9zr2Me#ZCOmega$LRob_l-svf?L&m)7
z?q@!hS6#0s;FU$2SLrwj!Fb)d+IU4kT^nD8jIHv@Vr#q_p;zT-3?g%wLbMUKV)#OA
znIes}K1W0CyXEKQBeoc2WV2csLtBbIMt1StILZFJZexkinP@;Gg?1>2>@aW(fD2E5
zcP;-Ech7s_AIjA+n4bOh2Q3Jzl>tWbinY(aD}LtP>UGFu9KUz(CV53S1`mHNLXWA5
zsIO{VJG{c&2R@6ev0c0x#7JI62=vOI69z{o2i;(UUlgfon^zs#?z`zDX!#Hgp+0mA
zwVxC8Ccw5d>30fNdJzFgDH)YZl~(emKB}m4Rpo12OE<ZyONp;*;YRzg?xTTUpx*wy
zlDosMs>NGh#Woz$@`Y<>>aaClJ?*qlfcuzy{MOg1?sSUwGta!rUPk0RPRT2Ex^-Sv
za5={9K8jZbmyB14j$Ut>R|S`hSEKbxg68s8C{Sojt5GtZGSq_)EjpCx>Sq@Z^X7)^
zX0QMFmMkb~Gj04jJB1{;_rM_nf3cg}G6_n#F=?otBOiV$7rULljh_;yT*}AA=2C*!
zN=&DGYn;)mSCoF=4(j9UJ0ZSiyliw7?yjgHJJl;h+vqL4_+Q`r$KUF3+?-V6XT##I
zrjicL<x8}T+n!+V>a71`pW&6cv?uZEgWIZn%VHMqZIMrzS9#itlkuPasK^J)0hlQM
zHjyA2G0H6pyMq<15S$CUgwuBE5b|!*wt!W`j|Wo%Cg6aU`a|7AJxUK%8afkTab2tY
zcIcG~iFsu%S-)~b+joH7K5sce5|HG8I=ni5`_IgF6<HdDNxWtZDOe@K$Vy7+-oI2n
z0`AdZ1a5xmXi7h{BPy2_#Jsup+$7M!xrSEO@3>07ToEJ+8#dZJoZ8ITfdO5jvYXnI
zX>na^<?iA4Y>h02fxNXd@NWn1fsay^FMV)pJ|>|IX4AaO)NQhZvcqFA2j`7Y87P!_
zJAF=*uljs-@o>+y>Pu|_T{XL!b0BD?<JBl=-?O@_sMYv>PVoJc1FH~5#4A&g!m9{j
zUVs6qwKW>St5E>KB3@ONtR&2VAMZ4m1=`i$MwEdB{*8H~z3;cvG{<&$R2J^%Mt63c
z{|1Erb=u_=Z~5rSbCS5c8n&NysI0Z}qwmRjEhfv^rNY$Om(vezy7Td`aD3eo(yvhK
zW$r)OKwj4CmEtG*o#g`U6L4w&>K`F}+-wmzz0>{%Mt=Xp>h;;LfBxRrZS4$(mYGO*
z)XyrEK&zD;F5*Z)X}kSNusmtp3to~4DyeMk!Yf>_R9cBonUdgA)62c4JdoX?cgksV
z0}H}e-uQP=QrSJ12a=z?5b%l*9ORL!MoYyQEvXU;g}gFgUb#TRCY(nuEzWSMRK%-O
zx`gq2MT_ePTU(G3hImD&#*FbwT`b?-852?Ss*MqPWkOou2|?l&2lb~RSo22Z1q=6q
z2&&&gA+3A{k5LHnM3ND#>+PY^bIEw+;%U^%Ws2q_6N*+QSgoX9;WcX>swwT7<EOa*
z0@EzzRO_U;W>IUUfJKuP^T?WP&*7tm>7#9Pd}CzXz_>(4l-zj@B|SnN0+|A3=(Z;e
z?{^;iP;1k{zbjg)!*O4}q**z9agE8RSnFgiA@Ry-Wj@Wkl6zeuD9tdP=LecvEA`qI
zdn+i8(f&Zcdh`2mpm_x)pZZyZLa4TeR~d>|1@3Efz0NoQ<kdhQG$7liH9mV|_`IGm
zJ+JV<eF)&>^}yP_y1fK}QyK6o#y05H@x&{QnpXyC&AV!8h8AF_&2Y-21QXFqNyD#X
zWYtG4`|$C21TcOj{$QpNpgpS_eXS&TtppTyV*Iag{Cy|R&o7-oAtU|Ty?hV*l~_(O
zSz9ajpE$Sg!6WLb&zHIl31!w_PCpO77{BamnP{}~+FRak1E^XzQ6IyN4DA4_sX(@Q
z{L@JY)GRv1gTpW4=HYycTIX`NK-P*^m0$T4HIbhy_ojo)E752K&9eJ*@RzhV0f}e<
zE$r1+LS7l8)%|BAwCagi5U)y+cySP5cvWeQ0D0Bj>?f3CfUcBwU6VW=IUymVU`+&2
zyfWdLSLw9ad<3{`6|X$DO|Paw;*|~p=%yWs{CrAl0d{^?E-)*tyB&JtzPkQ_j0&Cs
zt^6?_WQMtYfbe(whP2Y8@0-@g$1>;0M%NO&R!%<95lm_&U)6Y%-$v;JMRpup4eYSE
z&UOpc8SoYRY$u-O6?iQp;O{2!x?y@^Ls~h%Wc*Ez#-|*uN(X>4de=*@RN(~F%0CpX
zq{yxHN=bZf@gKBSx_!$<o2XyWvz_W0S2%44gR^{yayip=+^!JQxqI6LEebcTD?QDH
zAznqI&`=qHb1H{;)j*U>tt}%R{2Na-e^Fx#dKJU+%3ShV>CpLUO@>`?VTlBM<*DLV
zBB<N*CBUJde;bp<wH1_@6b@oR<&#7*l>UM^=2v7<ZjA4S@1h@mR&fYn)2}XBZ7q@g
zCgcdx$~Vpn|6Dm+NvV80>DTdz^v-Uqo9L|^JEfoP=!qecJLtV;39|SdsABjy1(ZwH
zE9dRpoTUv;d1kcd$E2zW|FJg@)blwhfaqX?^DB{8FGHG=NWN6Gl6WQlEaQo1Kk2<Q
zbVq&>C%=_~?^p7YrRKeJBn7QkulZgPR)?TRZ3+vOu8o`sPmNrC?SnIzS2|<_ub`YI
z(An0FA}(<O^UC?i;0EfI6GWroG^W(6gu(HEc{QMwjFvCW8XRAR&hMXiYzhqnjUW75
zh2IkF(A3<xK|zQT_JQj+?n@&ir9Ak_#QveFV$0bnuNf)~rp9Qc8S-xorsq|#Z#mAs
zt9Q{Ep<kIW<5h$|RbGvQKUV<Wa7*AagbHUFc0V;|hlOAc>t+N-%Nxc5G%KcV5th_L
zrEWqlVZAm#vPoKNLp7l7OR)!^?m;27&qDRu#LS|`6c798Z#}w#^<Y$&aG&60BaOET
zW3*-qyaL4EI0{TH9{Q)&H;yx2Z5n^1yz&V2O4_)^p0b;sAo}tFU?z-KC==S6h){zn
zOl@lNZ3WUWop&JWMjeB_x!cs!v3laxGID1ht?AIPa9Q!G+79W}Y8UI~XvoZ{)pNFy
zSHqa`%AN{lyh3ajugnR6(^ZvmWjeT#KaA}YRDs3bgKl^3x6bRJ+M*c{E)4Nn2@GFy
zqgW~hQgy&Dh}XG0kb-rqsjKE5p$_&C*J;BF3R=vl0rRYSSY}|68ubd(7sm<^N({do
zH_Em%UNIW>cbM@C{$6#w;-mfpsd~(G1%lzrGzk?8t)R;15((e_)fh8h2zkT(gl`WM
zfhho&-z`NC4#JRfi!Lp+o+NZQS{Ab#aJ5d0P%a}qbTgk6G+7;lyVncJ`pEf)44d%^
zFyj^AkAYYEypKT^0(dCku~#=I)Gb!)3_XVE8|!M1!2+{WrNihji6i$SDByCHCQW<F
z01%c4()yPa&vLFN9CxHd<*HJQR>@nPilMuQUijC?HR?1a_o@A?8Lt#(yz(LW;Hu!2
zKi?YqwrD{XZh67AL#%!aIW*I;i6no4j*+Z%P%r1hUH#R1@HP0ZLdwC?<_J8>8A6Px
zY42UIE(Vz=K1iyv>UDjU3GB8VnDGh@X1v;VOvfv3(Hgvd9Q*B+@6DKY9>IeT(zM-v
z^<dZmjI^!osYj+0*S7&6aWMEa>H^h-`gXdjE+HICOxHkq#Fo55j@B*-60~jV?Zu2&
z8Z%yP7p@?$ieK6B_BEWq&n>RI_uzTNNCT;=SpD!05Vx^S5U^+UY&iCoX^1mNKIL^K
z-b9Z#O*yc>%I~yu1cwgi0R1=q1tTpP<&|EDIa^Y=aO)?(pM3msK!WGrnSA>G4Hv5L
z2xxqYf9PS;d~IB~;p0ZW0?pcNnVQO#HI_en<krvDbO@sGYVBM9=aH}d+tQYKg|GM9
zub%q6Qt?Oe3gh1l@iVVl%W(Amoc)@>0MofC2(QrKm49)n!(nZ!dJ4Y@NP<Rcw}?&h
zD#mu|l{;r~F<4x8o@##~AQZJ4E~B|`t?E+@$;-EW{Str=pJq~(SuN7{KXtTJBnsE>
zb4dZp5N+=r_T;0H%};PHy!ET<Z9y>g-gkdLdH1=%2udqc#rw$ddC|?4nbS`dWD8Kf
zd^H4T8j_(dt!nP9l`US8R{ra931>{rE7HE#&y40(t*wM6uNv{2ygK{!&)z%q=C><e
z>2&P9<9VfD$gd~P^~;IUY5}hlM)4|RB(DasSzcvaI=#}}SW79CI2^HSxP^u?Td9U|
zK|BaoHe%CEHDvMl)A6o%<PFdu@g`AdUZX;?yh=#b>iyLg>7M}eF-HDf<DE-Swl@8q
zf8+f--?+fXX-=eaZ&jhma((aQx!XSd{cZU(YR530Z-P~PlQnP0pj#XxCt0+-I{roE
zSJt=+cvaec1g}zQo4n$0Wbf@}TD97EUfucTzw?Klcv^Ths_$$!uS}friq9Cqt8{$1
z^(ttdu6<iq^$H8uR@XT+vHOH8+~S3AWTMk<yWw<3Pjk$7+2-~5^v$IazNcP>OPCbr
ze!Rp_={$Wg-=1MaGlnk@aXRITI}Gt9{kp#07$QWT4%6)TQ^q@cON1nR=nwMM-~7*3
z`~z#}OSFvJ2liJF07cTREKe{1ubjX2|2$&w`8qQv3Fs^L=1ceD&U-tT*8la-CGxjk
z$>|`kmXH2t3I}}c-;~Q4@oMD_Yy8Zs!2ZOmmDeNklxP{b-K)mUw~&V@m+s)CICm^3
zY31vgw7j3RPKU#7`iw$##b@D_-1ySZ{01U4Js-=ff---K&>1j*S8^<ZV6<->I=s4q
zdNuqUoOQ~rZnT!VHFz$-E^fF;Y#@b;N(mL4tDU<9<d*DDL1aqIqvOOgHJFripg-sh
zHT=Ehd-ifmU2)A1LaRKO2(Ua?!BmI06oUg^h3S~9ysU?FYSccsg_dAYD?#$IpJ;qW
ziGM&+o@^Xg`=1;~SQ4%Q$<@|!t#;Y$gV%6r5(7c?zBtLe+R$;(yf_ChT3IJDmRG1;
z=?6;?w5Ol5|A&v2AHYfR<rHDs$b;fPqYDu2d#|pdR;mF$gVK3A<`wB?9#h-=OkftN
zK3}wQ3SMPoUit74rGFu>QjfS~yz1c+>Xkpw7*i|;zZuVY48C?di1w&Oyvh7X&H^~(
zo`S;f#8(+ua&vM7ylT6F<u@iPJ*V4e0J*WT@U}ck;_=|O-<L^ZDFBQFtz8~)TA{xJ
zCZxJ&t<2#@9OuZLthG|b2UL2R!L47nh2z}((rGsW+x4SBD|Z}ofotGSnmAc2Gp|mg
zzxn4!zatSw!fM~X6U(*{D*{mb9}2H9u-ES4zWM^*pVS0)wbE*I0wzL)r-m^6q&Zf(
zizkV0!(;6_IrMndg}Y^1Y!j~nTn@eR=NVi$_}hCD3e~18w}?GM+aMPpMQ9EpL{wBG
zau{ujh>qcyf*O`-NXg*^!t8FJvFnc&_37S6q2W^^dCzClS5Yfpe=OgU7|8>joH7b&
zvi9Y^nuITp4XBm3tDoy?Y2}w+IK%0OeI9G%4hZ9Rd<e91erW{)VLqOD6>H^dj#n}b
zrwRKgU_;;!y5$hph+ZpqK9;mkLgW?}9XsI-HBL|Gk)o*u*>qEC<uk89A~_sWz`~To
z5$4zGfmh+?@Opu76t6NIAM|9l_2P~O<Z{V)72tB{75~?M<DpnqaFgD8Q`Na&N@z>a
zaxh=Z9D@$O8hns9Fvj9w;wdOy!i>WTDS`~z7>Kp7@l6v-n$@^!TN+W7=c9CQNd&O_
z_!?v<d%~akwSNLW4AQ=R#U{>4?D>`4`44XV-{ls&zAgxT4ZVoobw-x|-%2Y*Kr^q3
zRwiDtUm5cX@BPoyrl?I`Wev)_GWOS6nRq3dHQC5cio3<aYaAvhLwNElH9eRZO5GAD
zou_ReO}Cw}dOqtZDud?W_-jZ-*J^%_!<b2Hjm#@0CYOX)S4gkq8lyc0&WNnfL&tRX
z&B_=$&q3h1$y4V}<}V5~iE%I&4*4}5#r3=oXt|f=a+$6IB7%}l>E|U1O^c?N^&ocX
z35nBe;^h}^&c9Sq_H`#imA;CopY2#XLz~@r>VdTC#DUIFJn}3HUv7n>m8s`wt>jxM
zj(^xKh`X8I5-oroOHc<{+7z!Eb8yK{tydzimX}{$mXf%8qh}YwEAJ<Ay9=+3{gGFd
ze;59oXF-myd6gsMjRSLV<Q27x<eN*bd8>Gp`1!_tco*C&eI&02qBVw}?F{nDA&Xtz
zyS1mu=&Mgc%&P%dUKLzcz4Ae$G2n+c#*=A*eBz9dYGndq8BEknmkiyRcJ@-zN*cKM
z#=>A5UojgAox(BeRQJTiGhW$Ed7ep>()x~Z-pap$L8CEhkXy2Z@KXI6eomd|;AshF
z%zEX?oiF@So`ZvErrt}?y%doe)M#b@fhhuoFFnG}{$N8Z)9J|_C%$Q(?U;w)xBllz
z-R_YV2)y<g`}6pxnxl>{fvVlrCEkbM#4nMX`|A6V7=U-BhvwAQSWd|_r55uO--J(z
zsLkQUjha6e+h>4R4P;)8g2*VpFf@W!2E)9X9^0T-{#+0x?fhFXy40KnUO(N}J8rUb
zUJpby%=-bH<G4nxeeW82bTTjK4rWnDP<z90?E(}J)BuVRm6n)oXX35lw1v7PDI;5c
zo|cZ8D+K@-Sl;7{06E65Tri?b&Kfgb@$q<G;q03<(U<nZTfdAN>uTiH5Fp1Z%qw#O
zk-)dNA%b{~wuP$bkg=XwkKuQK#kH0I2?on4TLbjLeA4A?rOYwGzD;sxfNi^D=D-ZM
zkIw!ALK^pmlj}1v7fm3RP$qi$Ih8^9@!X78g6-y28e${!;-&g0+or{3;g!Kv$}9K}
z8$(6XNOh)!>IRe2FC5+Q-!|F2z2m)Qlm|g};DS*d%{SRFuXL%xjC{~03+KVgsV4eR
z2dm+lwx&_t_91oB>kj$$L5=7=IvZCDCJAO#l{xIpGhWr0@v6o(!z*_lny-bq$$Dyg
z|52c!Q4<trZ#^0_P1(@!S0yD4;|8wI7;^o_{V*{0e`gth367gD;8;pUa??6yKL*m(
z&S>mV(;CoX1EYEYz5u#3{2lz>Yl`=@+R$u)ip$$-d#i_-GhPj1#w)>9$}4{^m~0%r
z|6x8JQy{lAFdkvzt|l-bxKRRlAj>)$P>kL{S0QxZjql)4CvL6mKHL<(GDmSSYntK#
zxOE5Ikc?hSsd6&!8ECP5tl@ergJXvA$705-5Hns~{k)PRT~9%h;XIybBW}84VMZFj
zU|t}{EG%OJ4814S1f{Gw%{9U{mQ1VM#dT*>xcB~bcXF?Qfrm13n$|*U-L64gk8%*p
zV=d^10Q+rG>@W=+F=o7)@yg*^<&^}5fH8KEf{ZbvZavtBa~xeOIQHW_H3ryX)W|U9
zU|U0S(F+`o%D}UrB{*v;?X=)3y9(-t2ZTM@e_K+ayg5M!kjS7SbRtLzrzPTyS2JE+
zd%S{wz>hDT{f-G`EUxi596IVX235T28&~5DBqeno`FOF$7}A#??aY|Ad8R|7g~By#
zXcyg)9QuznTnA_(TYe06#z0$d#w(2(ueO4#f>-)v53$FOw?puQ;pnnzKv|{zVphpQ
zQhTLbNL)J_3`*I(6CR^Z0Ycoex_`TMaeecTWr<R|SDuo0hH_8FSIQ?Jzr1s@;d0-^
zM5cGkg_rNF-c(PMyL^|i3GK~{Hc=Bm=om5y(zp`5%68j+Ub%Pa5hi7P{XW>Mm~n-8
zRT{;O5I~7b%c}@6ukfAxL$A@^%-hN<|Jw5Ad8JQy=F<NXvjwo16gnKuYD^`mOh-+%
zV0iDg8Q<I9+pPdbr~Pa9j<*B2Djm;XmstbKZ|=JA)-P3~?xztF!26SjE8?46s0xSr
z3on25(_cERtl`{>F&-A+ituW1Uw6jzyz*L^d6h%jT6tx7Wg)y`TykDP7M&+r8OSTv
zO8OFM+j%AL>PyHbc;);`%2hLCnq`r(Sw^-PxR=+G?2wqy(nr^Fla0LQ5^E)J9Y$~C
zAY{x}w_H!Z$1joHVvPVghCc10`o=LQ<@P6cUcdpH1(rlNS<5&zBEM1t1Za0&;6HfM
zPcZw#-WA~$+ih#S3S7wR7MDz5;Z=+-uYAZQ;8leNC8p<<{T8#@OmieI8?WRWPzjlu
zS2{>?_2ZIVW9CVXgg9SgK;|h6Kg&>Xmq7j@eHiF=E#I^2zHjP%(cif5Om?S(@4-18
z^ZjgUP9uD{ea3sYMBm${bSQ!W+{+6Y(#O~WYA&G5Bin+dd`p5CCuQ=2duROfDO>mO
z0R;keEq%m2u|H3?_sxIF;qUBAf$2N(vJramwrHYCfw#W_Y5qcKC0|nN`TRRDrM-a?
zx$Swr`u<H1r2>O6rNs3uRXG!{8s*=mK2C>p4isLMa^CswJ6h9SzMJHgb$rk-JEpd6
z&tQGrF*(j!>GpN!58HEO{GOfH&JcEA_tx|rfV=|t>g{j7MkM+0ar|h#!B4f_oY^V?
zw_Z=Yvf+{l?LH^r`jhs;+s`f@*85|wzIe05&s!qteuT&RdwJ83lzv71vDtZT{B#LJ
z%=Tc|p+0-zL@PcZ>s9)SN$C|$&!OMtm;oq@R315pze#!;zVskklY$U#922xXcB65C
zELCW0X(uw4GHc#nKxutR2d(TI`0%qdSeYg%`>JIY5<-V!u2~+;7g|x%3ywKK+D)su
zC!1Ykc6+ZC>_*`r9f78V<4<1MiQyO@)Fj_hZb$X}_~qTy5V!wxk{eDc)=IjO<Ov0C
z-@CuRiyU4GNilcAar*VgoRQ~Mv;5axxR6~f%w4=`$S9}Dil6e*`QkCfnVwf3%FT@Y
zN(uzk<M6pU4(*fls+{Hs;cQnHA`7o*0}dbtF$V>XSqcPJT+;mX{em$^`@q-Xh`fLM
zu4UX9P`HYtc;-Bf=qaz27jnLn4b1l!-#U)rI$zSeyio|3ledgH`_gTarqqa|d0@pc
z7w{$dXU=qe@yA_UeG{+XH0?a1<KuDZzX`6F?MPZV>XTyR75v9KqCLm0gWJA-Ez8Wl
zmF{ThIP9eo&**nl-oAS|`I2eHcm6yKp1J{~35{k|T8UQ+ldvQvK8?v}cM`-x3+Rn{
zEjeuyphuUpU;q5QFGb~<{5B^-!0bMJB7LfH>etmKLsg&8ehR5r@N2YLU)ZW;PMx$V
zk7O8)qzc2o{6aQ$GzW(=lzkA;ulyN^FRIeJ&%xjfvPE)s;U>MY8>O=k%W&aFDktf+
zMyvb=YPHd5>)b;>gY*v|uZ*59JbbZ~e>z?z|2@x9GOzHosg)8qSM8Ie_mrcOkiS{&
z>+S~H!YlME?>@D0ANKZ(M<67P=#!P7|03Wg5DCJaE}$pHzvuJz*PUKCUZEzwdYq06
z$q_33)GyeoB|ODPUa6(V6#vESOV;T)UIBR8N?MsW<-+)SuSHJhX(|KiCd|nw9ITY%
zl=LM&<y#Q%g-jTwSNva*lFTy*IiQw-(|mBU(V6B5c(imMnJKku&n~;b`k)EO$Cll$
z@^F-+$u^OA@X?c{3K9X@7*k++Ew1r4cKpnTym!H&*VE3dmPQJ?QVCUg_};y%$893m
zv~mg~p3}<aQU*8b!x!)3x#zoooiCxL<OwO`{Tp$5``jJIkGpWwC%?b#M;jz+=pLp;
zpGYeWXbuitnza%_ZukvK)%>v_Uzt|VVX_qX>ooCCypr&D{|dtsuSiBY952x=xtwr}
zyeiM2f_x8sceA{z0trSIvuC>e`6IV}aawrQ(8|Iq3Y2O1c@(BzCnBu`$BncSNuIPa
z;wQ*c@=WV~!KlKCSIE7R4qu|5<bC7b(>!BcxbM%jCYHzu{)IK1Y~>J)iOYXjueh8X
z9(JOH+;NzY^YnYGQ94e4Qy}zT@I`$5vqrC4S~*s)jBsY?)owlh%Pc$1`KcWJ_19^k
zWmK&!IG`QV7=nhAF)dx9Cb8oT1K$ft5qQS2nx|&_*G`xCY~TD6$<C#tbu-sxo9C@V
zu{<|tkp)P3<bdI|(zPO+y8lFS&&uC`US!|O_*sHE(v;g@kaUt?x%bgmM1v5dm3fIX
z0q9Z~!&=F+ds49*Nh`yA!8n#zSO$nw@hXK=Wl1Pm`X?LYSCWh>t<0ya>2ZBq7{@Dz
zVZSnI<%)WwKw9~ag;(k!39WU?7Mx)*@MnBz6c??0CTS(kt300>Wm=>9g+U45!9w}U
zQNDz|fVEQfBUCG+M?sqGTj0k27_&s!yLz&YPwiXMF}z|xkIP!QH?24Y`3kSn_yM<2
z;fYr%en+qP*9SJQSMI!)&dx(Osjw`&2%wa8pnHW)#&hlZY9pEfpY}!1r_@fg$2GUT
z*c2I-+L({M#_e8S63t?{<Vgz5yeNL6i>-CZLa#b4EdBk<!ForlJXq$Bz9+Y1v{E+S
z7rkBp1q-;3H!eJP!=sW2YK{1ew0>7)CHp}pj%a1pCRDv$%YXA_^vkqgNmq49<yYo8
zxX(A?!gG5|$a9c>Dnkw@3+u8a-GpQQVKvBwC{)S`ac;+Q{)$Ug@|}WL!@J(`<5B8n
zsDth&D`KtGzk#mj;E?aq(kta*j{8xKvR+nrg?{BX)>qGoR%XAFxuo3!0`-eDIUtTD
zQmOtjH#t(mMK_UGNW!F*M_1m2xqLdtIJO^^d~;28UMQDBW{JOR`5xT_6s|b$khM}m
z;`%bsN_W3@5g+hMAjkjtgDt&E&vxKAOH;A`7`+0&(hP3mi0TLG?MX^T`*D!gQ?tH)
zWKC9x9CE`W;Py0^q4p35Tf~S!O`a|lbI(oI*MEGA+ya-L!zCfr#_7kTN_%i~W~g?;
zhD_lq>z6KOTf@Kw=H|-QKmAM-0i7=Z<9zsp7~i}z<Qm01+mYETfyG5U6p|0Q`u;6{
zd3J8{L(wBDo@gc9_1AETV!pGt_-iGaXeFjk>y=q6(c=@X1h{-bzi0tbLVo|%pFfgf
zem5w80%VcG-@oB`iuUUt(j}Bp3NPhkQ`h+p@v3O0nIpG=!j~Rl%f9Y72S0`ViujCL
z`Niq7gw0x6p6$4O-Hq~=zFKx2Clxrk&g+#Eu>8|mE1?@Ye&Y0{?iZ5{<WJOJ60ZuG
zZ?^llvqS<8KZUoK)kBx>oA(2+ivFSvDNW7=${hA1h-Sl6`f2GFQ{Z1)DX7!QU4y#V
z+jp;9y$bVXn0JPfUIou~gb%e|<@L%+?Dnplbv;&a@Z|k21fT^@ASu-8Glo@o1oXp}
zF^K!pR3)(kjub#Ns|ERn1mSH$Ek`r)fet*bsJx2rztfV$p$gq}>W51qWSWDhT6z0<
zMegmMt?+7SUw6SD3$F^M;1x->doIMd7I{^_i=KFO!R#A9pjYs(w^h_2><lq{F(O2(
zVk5yzwlEq)uV}p{0x%;(hIX0jdv~wg1I@W-_3Qvar|JV^VP=S2&i&Ox9$6pg(=J?z
z2HH(KK7}2OyD_+#*KY&@$G8N%((~~cL%c!@ceV=uBjuIB2wu^9oypnsxYl@8To8oe
z)k`mr-Zvh3<$^-+YH07_T?B0ly%td06dJD<@<G#ww$|Wo!>k2z<D5&S+35*7Yt4*~
zHp##qma1M()*S|n)9OF^)r!ITI!G<_6BP%pU0posHbJIgyC@1apWs&*$tyF_e)l<D
zq#3VV$X0k|Ca?{m1pLwP%0U+?=9L81fH?)<Usnv;Ks(9tP%{F+W-(~U7%{F!VgS{l
zZV!hWqM4mW$fvZ1GNrjS%(Q4q$mGjeKDjfwRL)|ZE{BLd{|e_C@+7ftcYx6vDG5zK
zZ$0-HDZGmruV%cGK*2S@D>>4?IL=-=fQ{?cCdN#(Lv#4~Q8uWHjHi*U0dOg-r@Yw<
zS6zgGmhPf_re*<Vfs*K@w3@*#UnrG}lZcyZDtU=DcwiiwR0eSSBY3pGnbi%!U0s+^
zK&2X#62XjDHD<iJCV6E}uqLLgyfh$^47u)-`^h~PG6}-r)F2NU4&c)FE#)|Yr#Y$m
zS3bg|pupfzaCJiKXxwNW2XxEr(tC*d)qjVuPj)bvAVb$z25>wcO}-k~zKiRU0`JHT
ziGwNFdg4BWZkoo7SArR@u2o)@ASmwA>3Y#xeB;(&SWv~}*D?%7(4t0NpEP(5qS1eZ
z&^!c9%d;Bey$or{&7rd##^lqs(s>PV!nTX>xZfoPsmz%1YSWnUs)NhTt8!#3Ag$h_
z#nzE{VAG#AUua|bB!fql@oT^cn+v<^byGpgW<7<w!8HA|Ln*zG?7-IO6RU-r&pZf!
zJAFVST&J&B$Jsuqjr4q$OcAb90cO0K@k-+w<yF?ooB=<oPtNvaqd$4k=rqiDB!O48
zm0!8k->3x*&?sue2KP?*_MkMCg^YVJ6u064a)+tEDxtSzc&CX533&b60raBIF1Z5{
z^T50VJ*V82inNEFCReKZ6yGp^|F$Pa@=Dd0uzkET-`fPd!gt8O?l(-Ef>)OW+rTS)
z$J@M>?J*Uv?)^so_OZN+vrW88NY3~mujt^i>J|UjA0^ycX^4fTQ=K+5u+;`by9Faa
zf9g>$Is{o$F3uOAX6R|9n}QA2s5ND)rv?eiW#F+i0ZMzp?29hgUv}I{kfEYpa@swj
zr9%IxHmQMWGLo}TE&@TdPn0^01@elt(tiO-2zjM;7(#3xuTU#LUvKjYweqV@E2rUA
zIjwOedDYO$TEa&0ioWNOuWR%>-dpAsf+;bIS5=_kQt4F*%BX*^yo3Ir(HU?;nAE6<
zBAU)RH9H|D&y{L6+j)xDO7QRp)?E0ON3j-6VmFx@Kbir=W3q7HIOf_duFvaz(T}W!
z4J^hHx{KYwr1g}iNwqp=__Q=flfvNELAsTzbO0lH#r549ul$}Dlv)m?vRwjR`C5<Q
z6@t}d9IxaXM1c8p8qnaC(H+ez2}F$NRrV`|SNhw*tC?4fE%7Rt&$a<|5R!RB)d&#|
z!ZLa=y@X`i`uiU|qCRmgL*;?>GvW8(0P}in`ew^$<quwgOC>24|Es+JGw!b;DG)}?
z-&fvr--BZdrF=_*>UH0F-aCViTgsa|67C<7_nY9av$GdwJ{89e%Aj$f$@Z+Aoqt_k
z=f=$?Y2wNIR*;iO@vZB};d(a>|4z7sL*!dN$>I5y-7AmeluIBX?U#Z6BVVQ0%eRYH
zt^Le*F0HU%S?_25@pmM0+4BN$;N;54{mco5SGbY5w6FOz`xe^JEJ5*2c+2U?mIB5l
zOg>|F?lM)v{Sc~62~y;Whp(pn4In~P9+T7u&qLN<c{cNkWCbVVKYbooA@hPp@SSxZ
zEeT@+yAXZa$2RMg1Od2M{1?3aG@NFDoVnj|mlciHnC1W}1W%d>c_XF{3>TFNaIe$P
zo?qednHoDaGac8nkCKk;;KK0tzJ2#8`u!8Rr8NVB>KEUQHqMY_Db2emO-uyYMp^G!
zN!wZSd_nKYmI&8u%cM2jOiC+@hNg1n6iDOVxt=VB$7wZ?H>6;R1Z7NG$!6Sf?7L1Y
zxu@}hvYjTQs<P(`E)3_T6_)1U7?OGQH~)hqGRr*{`|#gwFRzMUsd$BfpnBQg^uA}>
z^P=!-`3s6LFpDfO{KR%w8&XI(gMU{?_y+C8e3P-9c{`7LyJP}uK9E-aFwM0M-_~Bd
zh0`qaP@IEfNahvpmo7Zi#pCj@i=fJL@@Y_2I)-wR!lpjL0B@$+Q83WT%q!mGvV?11
zwV+*Njmxc9<){tzXk1ZR6&MMwVYn`%hmJfLq6YE4=<a*|ecuLWGx3Q8RNCHfNP#2Z
z)xuyL9#i}@J22}q0o_|zz)1>khRTq8(?K4lOaXvxJOOWwB?_o<w?CiEqO_7cLD~uk
zPSw(N(K1BYPY6Zo_UFx_UULqW!L7zxnIdC?#V1`jj(Zo0+l$CrnM0D+!!hyd!p)zU
z_}js&By;wX3EXik@6jvYeUny-U%BtZ8Hm99nKykC14ELem6=z-+f_g7wEQf5i^;}?
zgx-s%nw)ry{Lj3qZYQmLy70<H5FS!_UcjH6MY!@jnr`3wz_(PtNac||beSF`F`MBP
zBa9qQMq9X4dgX#zXg#*~$OW3JZchFUj;xuLW^6(n70U$Y(L3}&C)<xVf7|xRw;&u-
zAlX%31IEYj0`W;xQhAC|BtDH)x*75?p4%qfyKDKFl!w;5Vyy%~8`qsv+28DQzN=^@
zL8jp)ko`vumbRi<9mwQJvswF<^n+qW3a{Vz(Ri%{%q{)}NcmtfrsP%f87;4@BY9-y
zcb(sU0I<PjN45LY!xL=>1LBo5=<(-o(rYY=xA?OVgn(~9|2FUn!$0J7Z1-kiLS8AY
z-1Wqr!hhmb;v3(B$b`(iG7;t$mopFbKIf@C$p5UxDK(X~p!3@dErh(%aL;=?TWN&2
zBzmP!*rjUtdg$;6%L=wRx#s$>hs2+<G8Wk0X-qzM_vi23`sM@TMhO+txGe&gFj?du
z8pGLy`t_a^|Hs8@YF<$BPu0$^-#c!Vd*#P17+x#Ku#FnXXbsC2d*7<27zcbwDx~!*
z3vmBk*)KggEEQafGlR_>-1?P)1fy2suRdg6nFzaA{t}8OZgRnvcva1>5jJpgBKegP
z!D%J+&+MM#y>8Rr7O(j98DN*vN=S!zMZEnn2PS?>9EObXz2`z&u<$tj03V^^YSzj|
z1S|&aqZ*V4c@=48{wc=<$6jy@Ww4)$SJUEh>s1LIfichZYA~y&x;K#ddSCSK-9ul_
znl|P&muD!)B^cWsZ}Pny$Z{!@db(H9g3Lq<0+fYJPYS{{?4UfzRR6nr7>%E;Bly`4
zjUQ>YRW<WM@~?~bp;HNdBLCLHLuMax)+26yT0{I7C1;FE)C_1wZ~Q@;ijqxQ>y;R%
zy<V9^T)uewm&;FFv{1i!+Tm4mKl9HwgjabEE)lX;LW?7>mY4N@=B%?x9~b|&-|p1t
zSt~2v@_ZI@VZOb7-ZgY3b`|hO;cc)!e)ws<#)?{rzjT;+<+bvSJZ5uwfd4#ON(|(U
ztCQ~Iy_kNwmscm!vmFj0O!sU@c(v`=X1(&~Eq%@CIIGPY``;l9nTcC&9tX5CK>%{7
z1qf=+bjeH*5^K$+!j*;N{QJvAA8q`?<K5r8OTvYhH7BwKe0gYeEq*1fq+lF8O|^L9
zxld>seq^mR6c?cS;A|Qcs;pO<hv43kBngwNW9HylE34LlI$Es+;7>W`#H~;QvQ}o}
z1X>BFL%a&Kvd1eFzVrxN_A|H6=GwoJR+eRcyyXaJW#ZNFe&+9cEkIQwhP-$JiIlX`
z^A-Zd-#PK3-nXB57-%J%t~|NUBxkD3AB*^(8*cBDK;6Sn6<&F*OgyAh$N$_fSRyHL
z@+);0Gy9Dv3~Ob*ddPKj<liw_&$MZxA7MN7%AdPBR8<-Y_oNA=THJE>na3_D*m6%b
zQ0!YP&bi#^R(t`&+H};v_@=?tsgoUvefdGw+~VIM!|Y5P=59O<ERVL8-FoZ17JBO%
z#<UAS8laV+#XQZCln0(IZk<=OpZT3OaK@_^6tC9nIm&kN>fCR<CMI58F#C;9h0Dz=
z!YIAcHsaw<BFO;*WSDPbFiS+X^9*sbh$?BGh;7yi2)dUGY&4=u)4w2MBe*vk21h(?
z+ZxWigzP;@zI~UR8dZ*i1ZA5nDoJOI6+jPn_2Nzi$gQ6|K@Ln%<xI5OW?rFXMs8tk
z5YgsOk5>uBo7)Cnk@NWLzk}0?S9r-a)(Bojxa7Q=2K*l;+98d)B;!@}?oymLj;>VU
zG=gO~A)i0G;Ua7iQoQkl<ap@OevAMCcpaJ>jKRcplM!g(6sO%B{7#iNmo9^Dh%qKL
zju>fcc@<8=5jb~F6KyjA?_tKPsqiPstIgob@JgREl1=T{B?{fjLm-XBrk@J+hp6m|
zvm-EedWBh^O`}$2(DKBsy3`qvJNuZ9gl03qF{XAU_9<UOMqr1!EnEn<8Zdsa)c~${
z30%oLF#cMF8LtA&cr^l73$NfG#BP0UE?M>w7D(EO7iBt(X|-7&H=TNbmo^wREoyXp
z0qi`=;m3++BXY`O(=iz#D84MaXy`X2<d_|VKJ?6J5W1YTSO}!;bXzxDM42dt>KHR#
z0cO1V<KdN_vkbPD%R`#kAxLNR(CtvSBJfzI2IGe&4JdYJr0TDx^LI5JiZJR#is=Vw
zF$in+dTWe?I-?x3MOnRYHfUREWiEj3sDK%-9A>;?T*JKb=UwuJdW^1k7077KZlwN9
z**=X5CL7^!%4n^j@GTt|L%NOjCYnU45R5<Vdt2k-RA8&t{(@_A(^zV**Bg7ol210m
zcApM2UJ+)zD!Ar&rGq@W?aCH(rNNca2K4v<><P5IVNf5EAzpwWoC+~zJ1=L{>1a&N
z00IzQ=NP`A!?voMt@qHN+adtT2pk+Ufae>f19#9jh(j$U&JhUEt;LL2owCh%)kC)y
z+rTS1Z=u767*UCL%jBYR;5#ETK-;(Py#tNXpj{Q<fO;XW`hKRM<A#8xwC#BOVShn)
z&JjCb^ikfp&a*jsC;a1=cUH{|a861o2^H^P)R8*a+wiS&ujaSY8Tz9}M3Zy+4SBWO
zIiSI-RNr9a-zu-nyXXP0@Llv^<F(PeYBv3q<duFCo<8+)s|1is<`umIM6dT=US9Rk
z(XtjUp<cnix)X*NSZI(eRqA4Nu}hs7KYnU?zYMwB8e8yfscs4i<+}yV3A2_l*%;GE
z=B2sF;s8!oYRzMNJ!3)!Ur76+n<08}z4}OIo1yz;4cE00{sV9iG2J|E?B>280c$Lj
z)2iWk<?Abk-72r#cRL8ft4J%S;Z?y^!z=uLQ9d(syeh{E_+@wZdz<l?npZ<myz*@w
zV*B-~9M#AM?Yn*s9Z%b2ytrm~FxeQWTLqWVnD@5GTM51)t6`Uc-L@Ao^ey3j`dy$$
z8E(rqulGfFpd1T_$R<(@2oJoo2IPea-deE-t(C?~H5#8$F8+|iLteG&I}NXn7g;R4
z3bZoBW_dLVmRCdlnUHTm-hTAtRJ<}&SG?+V0s3a~pYFK)ywVupRRfn=ugZxU3f!wk
z&Rf>QCP2G{!Gd%HlBWA;0U(X!uyEg>sZVRwCKvYm>t|Kv&G)Toy8%NK`o^|=_pRcm
zk6zVBxCwBt4AIHq&j!gJLG*oY&bK6ZaS<D1vH{GS`%&2!y@oZB5ugKa{!8(~%qQXR
z-|$c-_pwvzdvN()oA(CB?ITlslE2J>3x_Z~MK(S{<X2Yd>j`_tyUziy&~3EgQkQMv
z)ob^ckGL6GAD2I;<9c88-~G8nHv0_OPr|?UyVYi=A{bur_u#3snNPwsZ$00LSD4O6
z-#?uxgz<@2C4JL}t8|_|x-oxjRWUGwzE2PNoYF}K$I1B1FY3ys@4L^j-zuU>#i-o^
z?!Rv3K`5l3^*i6w4J3oO+<FE7xe^zsL~FPb7^q8T<fQPH6t<9=k+@=JC<qiLx6jH`
z^!p)nj8wBZVmco_hG_zC)J7QT-X9!4vvB-09>0C}ip?6T+_Y6eDGxN^aV`&rV<JG!
z4<BcPP%-irs;7R9v+o;DJ>YB(IaXXOS_xNCq~3jwB)f#`3C=<i%Cvh09(VUeXY5>h
zn0^)l@A9K`)=FtvNgs|E;Fx~4436hikqok5>B9-z!K=`P#6VCzC!G>u?!=#2t&9?}
zzf05N6#)68_T~Zdfd3+on0c&CT%{@_Pt;hRB^9_N+M3dVW8jr82B-538H9PeoD7w2
zsd$Cq9T)X9u@MgP+F#Pjdn~Wyctod2fL0Sex4gg5*9KF|3PUryORZP%Z<M%JYv(O+
zKdHU+a4zGjtqWRNgq*dvzp<jmB?J!IdaO?T*tNW_H58!dG9NsK1205V<usbh`}8@N
zFvsk|mS^|MQoh$Eg4xNb-s`sqWP=eP+?MUv>{s$rk)KM9@_R5CUS_qZbf{~=2IgY`
zGZF7smh`cSbNX;PztqY?RpFBG%IhHUDrsNlmD!UG#^asqX-_r|!HtL>O#7ne5Jdf;
z#_}o^W*IaqX(jWvZ2gz}UW;!nvYBw@No|6+Rk&3d-n-X$dFtJu&ihq>&Xl$Xm3|G^
z#8*tO(to3q-U>EhN8p5M8>9lw9e{}3z|mHwA3hHC>=6Z1VEPt9H1>tgx9Ft29m#sh
z|K;+iWb?fx5$Y{Sao+wKdhb}R#9aOggy!}vK<rnRt0+}8w}rq|2Apf_IqxJXT@tJ>
zo&Ap74uG<8Cuxq}5B(Ih@}{Dd?4Q=@r%MA`xgDr@)$}VRaQDi||K~eaPuGtmt<=IH
z({P%wci$B^BvF1PiHqi~itqSFYe6a<%_|Pi6A^_Voj1<orRGlqMB$tZOGdrVxsj60
zZD2^ffF_ulS0tCUX2rN7dIkT$OoPuN(jb$~v}wo;+AT3m32f}oUO0ir;>RWPB_7N#
z;og*GgWgi|6ag1*_$`XGHF_GKK?gHC1uf1+kn*Guxz{Cv*~uyIEWL}mVv|e>Mri7%
z<n(J?7$^IZ)~`G&6RSY5pjU^v?^-$yW=R~-ekIC^NgpRli|ah{gRJYHyHF@uUm9Kw
zYh`DzU;l^}d4>1#7M5JKGFVo;;!|W-kwpaY3gcuS(E5V~EwZ)3Tj>DOEfud?NhP>_
z&KZNh9@u$VXB4kAte*?8yt+bqC82$oxB1&82&z2}J7E%JISR(bkj1t1R%*S!G%X+s
zS6JX=4JaSioG3&Qx#UX}U(1{zq9ZovOFyG^oKu;IRDBa!mB$ejqrqw7kowJA8Cv(I
zA09}j8K_NP`}t#VocBei-;BMG_C<#>>^Pdmh?;|<y?<kV)RUXvYh|%N+(kcwBdd@I
znI&C#`7SdD=k-bxk`c%;p~&lKUPXKTHc|FPSG-DEnR(Uxy&dp?kXLzMbmEoM*|dIV
z3sc&iiI=o8;w_)Xd|NyMab(?7@v13sVLEi9xkd5nq<)u3gPw{Yt9eH?<Q0ae`kt1U
z)Ka_&w{-dHK|+G%RTW3gzU7hW)^SPn3jT#tW1vW0SV3@`0Z`E;12~{#xtap?X#^9$
zg`7@W1D06~L0TGGV&V82&@^At^YP4Db!l#bT+9SQerulD_$eIikhi=BVAiS0Gl!^+
zd0ZuC&`(aL_)?y(R;qV~7-0YAhZfthFZ!O<{|kidjvt>DvI1`ubx_VgD-SH4h7uYQ
z`}ImhojwGHOQMNaxe5R->JYC+X=RCz!j~Rl`+d<<E^BTME?UW_J6Dbk?Tc;-gGwR$
zqCdZaL`qs|dHZ5X2khYab{2S5c*5Rm=G9RMSCNh1TJx4n5y)%emE*IDAp4xF?$7o8
zXQ;2%1P#%UJ=9yVHDg{;$l^M56VI#BxMF&xgGQodFMzAOdwAc$E%*Gn3#q{+uI(E-
z<Y6G(+Zst^)Qwk6)Oc9tUtP!|Lu<S>z)}$--+hT6*zwXBP)aK%57GSsgs<y&nv7w1
zmQ5sC%Q~H2pOU8>O--K?1H7Vr(Rr)w8Lt4Nd6kaG@T&PP`h~ZC^~u}yKIeZ7yi%tF
zyz=J_gcJ!p>Pv(M5w{)T2ewVn$hkj%=(dSZ5h_eI)9j(s>Sj<S2$|#(jM997fs<gn
zTpruGk8K5`d4-nQ%)aP-{HgG24AM|tg#+*s8~=}vSJQz13#GUIkW;_LSx^x!bdqa0
z!^v?C7!o;aF!~^MI?v`}Oy6O2X*;7<SX51^niHMWYA!Nh93JCm$q*|2HugX%TK~0-
z`pq~jTV%!=ucpF`S1#nL;?;GB&O8YJ)s&K2)!NT!eVWZc?|QPKO_Nqz7uVfnL^B%-
zJvbBTo7)>A`eCLflx1<I!*6VaWU{$H8+S%RH^ddguAJ4g4Buds1y5336`(xYXbi_5
zdC@90AJ{=%<$0WQb|6h>+k@-(j-^p9s$j;ef*G%DEv{8wrT?Y@TW8mDyo0=J0FKP-
z)9KB77|c}!fiqvL&V6ugTRs9`^~DCeSEdI*A#XbM033`NT{%smZ&<+?QPvLN(STK%
zG-1k|d+qqhk`@@V?_u?!EfA(7&PDyI_IS*ARb$30KDa7)h5s}fFL?^X3iH&%eho1?
z=Q<VeUP`vl30|chgh|BRVx9A_sLe7+Qc*GBF6cRYFR+k}uHm|F*nV3?b2>TMfRUeP
zIx<?O{!mSSHV5w2f$3(v%4n8h#;Z223SRm1A-I{2M$?o6AVKDVuJ#~D#q;OeWycg5
zi%Ntc$S}gbz$h%HA9R;dPRz>Ta0>GdKIUYhguDwO|CMk?8Om(MCC*+uz1k|mRhw~O
zuIrZFgj9{ej8}jeueKfA$*Xdq0$#R87fd^m;r5Qv(0hm8qp?OI`CVCV(Qsj2nn&gW
zFgyaW`ps5);1;+t0O&=F>kG#crJyf~o50<e=S_W>I1Lj8;Z;bQi439kbXu74D#VOe
zA+91`!9N_<qUH%R*uQrE!1{e);_-DTYrU!_&}P6nNN3lv-eQCl+VLzL6J&hu!oHx(
zixH|{N#~KFJ3uy9uwX28Y&0883b^of751HYrg~?H-U*j|!d05OmlDzaM>0^axXB|7
z#uWQ=yYtF-Ej0RjiOa$(w$IPReb_!;m2Y)oUPXHY7hGMu(hH;NU3UrW@hTk)wue{v
ziavg(ap`&WlZ*5&)YkQC>>ON|bv*h*hpc7jw`zsotsMIc5HLxRp|XMCV+OHu&&yDN
zp6Ql^LyTFxFSwBQMR(!)i*KQ6lydMvVQUg93`Pd1@EY|bv^;015<htIexTQo{SCIx
ztKf_H?ctUAt})<MUn>b$1+P2;{&#s5U>kUK|2NfsNEC7@dDVQ!-eSPjg@0TK9*)Gp
zu1h9{5Qt@wo!L5`77eoo$SFWcg0UCU=_bVk6gCn?YmeRmR{-Il#E|`3U}(bHwTscp
zbVOH4-#FGW=R5nN8?-*YP5@VBOpn#ATywyAVT>>kaCvw&Y@cCXseRN7l2(r9Rg5mL
z(!nL;74o+FmNDl4rm;z0WxtZkqrS6*)1;x>%PahL^OIljr$?LAD}UYvkG(ay$D+N2
zq?f3hFrU_{%>oveM|}^j_EH6|a7)lO(Ko$u-x=n#il6pXqX-6?XI$*cApDs*<M1=7
z6;r+?!TdchWWE2#{|w{aJ<_kD29qZb0Q3E|+PfFDa__HmxOiLY<Lk5?2BwekZ-4$&
z*{D3n-$B2V!-03c`;P2K2~hc}Z8g9GlZW{GaR|)bTrN+QeqA2q6$F0#@(mREw&(e4
z^zzktE8m1I@TzQ+o{>c}X=S~S`oE6bNB!TH)}dZnEBW=q+_*-w%J<`d7SAm|Ew6-f
zIX)-y>T#eA`_xP4Rw(P5hl`xJ{z$yu$Drn|=J{tA52N;F-X4EJ%K264k2}<E?H@c3
z#VcCL#io@9IL%qx@;uGFg21=$evJx~Yh6ra`mfik^7T;$f9KxzHyy9|zog1^EnJ;}
z-l*4fS=3Y8k49(xs0AfMsm<h42HFe8CF~VP*2q|QfSIn}xS#eUzgbg_#^;g_G{4?B
zfbLE0gvVtIqE^-+QhE4PrOBL-bWECV7c7~EghMOu8+7PlGhf(s{ICB9smYgLV09>N
z=KjYXJGg!y45a%`JO&zc*P9PZ1QI5Uqxa=SwFUj9GLX`}b3Jj61S?4u9<xR#KBc`j
zl#r?PG0t;e&goxw;R1;};KEH<p6}u@2`Chva`_ifNywTV#yDSvt?>$qx76}0LG?ag
zM_!3^@`Gt~M$}###49sr9|1!E<Vn(?CfOSNWL~je0QZt`ptPyYH5kOJCJ*P&ui_Sk
z*w%%^yN)0GkmBq8{5k$}uU_|uUo0*mug;T_ex;Nxmvi}ro24H;4RPR@ct!E?HwY-f
zL!W`<mFm;Iz?pL^xdW;`MFRTaW2Y#Wo1n7K<X&v@Mf-ds-=6g9>~Gu}*ML@fUctX`
ziKO8%^;R_W+EyA)!7kMs!uk{%hPA(m>?*UplzwHL{krTINtw#;h$Z_v>ECgbfAbcv
ze)OcSOO8(!S91iwz;BaDjnKGwV;Sfaw+hL~;Fz7H30gUNuU~ZfvfgQspZFs&7m8QX
zCIZW@tnTeu{TmTSg2YcE%kd99{%ZCsF#_b9+(xzkc?0}=K60AUcf6AF?EBkau?V6X
zQb^Xy3%7hywoTgo$VJR|J9!0&WKK=YiC1gCb9)2ZeTjA)J%Rov?V}#{k!qrfeE9H*
zR7mXSNh}J_4X=)_yspMz#ZSj8z6AqIWP=i)ka(CTw%KS(YAODsrW?}jDV;Q&=kn}X
z-Qa$d;#cKNyn1j^g&+O_{ghTtR{C8*DG&OUD1u@!xCGgy{c5Xxbz8VSjHlKs??qB<
z9l~RH=-_BTwD75!OU<R<d4H{*Jz+zl32>BSGvT@ejx#(!;kwV>)#I58M&Q)bJ!~^f
z!OLzAFA&K~&8#A);w5(KI#PL5W6QlRktwyZ^zE!cD$|=ze_J#TPN~VXR^l;DU<qk1
zoZ@E!po@3-Z|}YCp`YDFZXE_f7DW?V`>V&;N&C0w0zgtYN$-`1=HRtf&bRW_HV43|
z3Yn5ut4=HF=@1I&=NrPS)3P^kdTu~k`I>uY$nK-wh2ewr{KTvC-_SfKwD=j2lLJR-
zC9Plash%SvE>4J7B|h;g^A>v|7Qks`Sk9k6crW=hd6EY$W#Z#O_6pM}M&n^a(jimq
zeC#XSbCbm;8?2RKzRG1mXsz6gUX@TnxJ)}RL{E>JuN{;}_ylSjv`eBwZnGQ#FMaUn
z#@^MFU}#4da>Xfv+7~@v#fC|Ht$U<fs&MX9cpy&(cis0*E>CU=xz{<T=q9Ao#dR|W
z&q;yVQ*#_yLz+_f!qUSaG||(HqLqN%%a5Qo{Rjq05~g>bBcc~S&c!d<>b9r6@bXtb
z{ncJnYK&m=6%G-&sA3S8{!S`3ou=|YAXKoFr=gWWzHMxlS0szhuk_9)E>nJf0(g}x
zsQgNv;wj+0ddthGTNzR*KMs*|!8pue`TeM>hx<tnkKaV^uN!Y56B6R52{rO6Y2O0*
zWl{!J9#hWUR1D}}bGhF!uax#tKdNQg^;0~(>nY?Fq+f3Q!^Ok)bi$_lA<Xx=JhWaZ
zS_xOPR+fBQdgWHS#v}1c2aN$pmAJLeC+!U8H6r$O5$-RI&A;*{*@#QUqtnw+y<@zh
zk(${}PcU$Co%r;PrR=g%d~8nhwk_0ad7bx>21i|`b8`2}Kh*0T^T*O$iCuRt54C;D
zH$SjTTA8S?_C*IIw?Fp^nD*)-(fZx*Z%^xz0;5ekCJ!C@gikR%YfaH94!`5a*e9W0
z^GgrkO7V9sqp0aPX00&v=@68%nU$OJaD+~Ic7RrX@@m$~zk-mgl_&TA{9jVODXAVZ
zucq4FuI!_pfE8T+g0wQTowRaInlEYPt8$w6QKuOI{W#jHOa;=q*crns;_ZtV=fsOQ
zqaVataBlMK{nC$$PR$=XN$c;2Ubntd#jA8Mhkl%&JQ1%-n#8O0BYhkWyd_;oIz@Mt
z_<$V~+{c<ueH@ui5$A7#enh-F%`Z0YTBZ%TgZOZqZY1ARhbQebd0DN5kgS!Z|I#f9
zO0UX(?~FZB|7`(zB`0Zo$Vh!S{M=Idunx4)%LD@bzMI3Y<$Ih$dEh|At~DYXk#J-Q
zO_?sCp=F#W^O;Nb2b*{U^PAqx?6mQf-En4}!Z~Z2h^0Qj`=S>=WpR1rzUVN#^Au+H
z%2WK#kk~eS!X{w3%t&+OTAOg&b13Qyzsxb;zu|e>J{{!A|M0A68Gt2{QqFU5er?6(
ztM#j?m6=y5edHBA#z`qidC;%KSIS8%wO@(1xAR3ryh>Vm&mgZDD17M=w%<oR#UZU+
zSL2giubeXv!EgP~GwatauH|=q8qW|isen<^^B3;Rv+sOK@oIgQRW*V6>3D^Jj?L3A
za3M>4N`EK)=8xlHIxQqW^x9+8-SCzmKL1|s!trBpiQ*rAO8iRlJR1E7lXCHQuN+sC
zZXOTvX;_}DmGVoOtd*=+OFz0P-$HkBzH~|Ud&iK3(k`R)3iOU8Pu>MBBd3L$Uh&g?
zItJ5BHh3_XH#vh8vIID^@)`r4_V!cQonJ}SFWl%CWsScEwTQ~8@0}Llhsuc3m%r3<
zc8;LkSO5t0ez!o@f~rW%g@=MwlgDcQlBdQJvg61JIS#?~z4E+L`>0QaKRR9o*nVDR
z34`NNysB_Xd3BGxi|%-J;jLeO{MMay3L&rLsMVtYo!8lUChy+kcS|az1561a0UKJZ
zBj6_2#yW(n(IvvR0ZdFTHjF=9<qmGYH+e%m`=}vIb%ruCM|DYh1s><{R^p>@WR26Q
zc?Mn#Fd;9elsWRIafNu*+eiIRk5>xn()RHx&ymOSY8x<`SH=agyuwRBlCiw<=L%Yw
z0dA~l$$1NdFJnT>xe-##F|4+>wt`XfFAJU&k4G|eRDi)Mb6@S$E^X5wsB)?Md5y58
z(n}H%%!IcR${@9d@mrYjY7DM^UM-gw&huhomsfpU1HAI*4!O9j#QY;|HS_?*fX1i;
zIYi#@bPU$&Uf&y{@7U{^BQAugQw=n6qg4in`Wn2tq?^qZ5-#a+4}1afp6a2}jd(5S
zUIC`NVFS0t#(eGVT%A@UGNdpa+oC1ad{Y4FcSd`IoXd<?BQfKZ3yhI-xfHy*PW<)`
z@E)oIM0P)^u18Do-lq`n{LUw?+C&D@0AtPJ?_{RLdCj%dA*#H`;@TiVJCB|;+;APP
z3QvpuJd8sFb7Q-Yt3qU2bTI5UMUX}WT6+hi0$QF+Vjly}cqN$eigB&;3jNB?grZ)f
z71VPIH=Z+USC(%?hApnS;iBd@52S;Z4N&)!OoF=P3|?z*jbM5x4whXgJIA5^Txnna
zp}y?}cW-fa;>wQb4;nYD$7@)IIXO+yml>}ZGhVfDjqyr{>JharkSKbcYhvEg>6T98
zEj7tPD04H(9O6bIK8ZCAhT1Q_s||@S4YTPKN=Unq%+8SmU`V6X)3W^`&Q3~}SMiHm
zG=k_gy~aHBnDJ^1X1vn48hPc<yO8lsmvR%}vbNxshh?y3Ds+a9gsN@abOySL6hOww
z4(i`@hr49`#leNMHv!F7T!zU8XWCjm?=0vfs4N0Yj?<2&n^T2o=-QQXI#V<()4_~a
zj2W*0S1+&NU;XMv{4gt*wN$%N`u@tXFwC1TH+F!*b(Zj*d4>LLtL0N9P<2W-sK%nX
z#r1=<>}_y?_U`?(`JwmVf|R_3+_EQ^q{U9|Md8+mLPy<Qb#vgWf*0QU-&B6Y$8X(*
zKO6f!dZmf+$#Z`h_esH@F0XRav+3v^PktLLneGStF8$_smEo(IafNtAua|vtkxi|5
zb>T(`&#&krua2I)_q}2VprSZ{jF7P!SBh7$U&&QU$NaZSF8SE1K%h8gILe7QTQGzf
zVUyQ^y5%}`<4a+hh+HISAz%!&dgyHTZC8V55O&<gzA<v^APt_sYywabS!w|niCag;
z)v1v7hQJQr`uyvqpGt?<$aYI9RQOZj)nC4iri*#iFkOU*SDVCT;Fa2HAP#q|h(4rg
zAh*jE=9LR_FllArmhRAyRk$#ze(;B5QB`_wznGvD2!)=HmX;jE!A9P*r;yT2pY-z8
z4yK@EHfXckWSn}p`7ZPzO5%_m*M<JdaJ{!0dr|Z^1u$CB%8>7cw|@2MKi67Gd@UV5
zTp%CBHO{M{K`0M15w99rIht4DM~x$4c}1HOK8iKk7GBNU4eEtgCY-9t)^j_gIUT$T
zc{QMw&6djvNtIgDoZ3C!UAfQ*N^sBW*`3GAI0oQkX-q)j`+RlvU(>GC<)=<|Og6rA
z`fK@9T>L~AIzwl_>(3v#^^23K40vPOK8wHqUHhF+KYbVM_Q&qX>y6Mhi|arI_A8+<
z;Km<VUj=I7euXrx!#z;x^<A{^xx2rRcY4dmvk3KFEq)|RP7rq$`cgv0-?MTLZT-T5
zC0y{0fBJWx1CCYjaeieza~uYJ4;OE3J=t(oPQ0qBmUv~t)xOT<Q)0m39~NGT-FPc+
z+@2QZbl{k{d?68BM6>z6e!f)p##7(M-mXjvO_|<MiA+ar2L}UwWuI5L+e;}A;<w+w
z4@L!?mZpuaIUKi-fm?3<?lCC8Y@R?7uy%DiT6`fjsoKjg-qRET!lpe|=^zSV9LN++
zw;5htYQ2&m!De2hP^GMwmU(E>esT+mPm_(h#CujwfL4Np{q6)@TKm^OFIq`LnRYSw
z&Z)2Reyel|W%2V>{9!+iiLgJe;<PeLq)wm1i`1su>tV-&x1@x+=ZYJ509l(pb?|P2
zJY*1N!!dp%k-oR(4G36Vpy!JwrgZj%LlF<-s$&}qhjpP2e~<0DdGI$Ko)@qNQCfk7
z42nt>#PZv%Vp5gy`0cxo<1to^_iNDD!BsBX&?>kswRx+($;Pv<l&yD2FAo23<t&(j
z^1V~%E2d6OV@<Sk>C}$J^*gmmb%aVQ)q|q}tsLZ)l*)Ce+H}bRB=-=1;ofi5yBB`=
zSS(47Er1rU9EN#CfFS|1$bO~bRnkg0otjtEU^99J|Msn(OLta#0s}e&UFVX(P5!|s
zdhHo}W_=2!bb7C@W|7L5a#78OT03yN7uo&A+>(cs5(o@VT8WLC!qd72fnF|g`L6xj
zgXL64KV41cS(2pE-ihK|BV=>>ofGnOgxS=1G?k!EF54*~<GClO4s77l(de{PJuD$6
z8w(G={VQUvp+q83?(m9FwIk5v75SB`$Ip-v%2qK_<y6{I<)CV0@DkqP6>8$e3Gu3!
z4zJqu#nj}U`+Pf7(R#MH@Nm{jB^H@iXu4-F1R|mr4MJXJkj8z__3)LS{~}cZ(<xOz
zkc=Ms3?lqk;saVlngW~Q)$udC>HQw01a3u0%ler}$<CYO6`@n4&Lu%luOt)@Rxe)n
znFczA`WY5r7wvQB0s*#eUMur07@lUw3CShgxwP{CsasgKb{sS5pjO_`4TIr+!&huG
zbWXKaf;8)5urHhk#)4|A^T|hwnj#YkNN$=9U7Y0RM=Hw{iGWVQyx&vHLZ#y`<)ZdO
z3dlJ+pNS$IqQxfa@ZZId1J&!q^>a+mE7Hp2Jl!^08CN;oRaGtVDy}lg9EZy#jEM;*
zUg2pOeoACSFJCa)t*6qXWI*PX>SNY)0M(^wn0W{(SNC&`7O!fJqgimX3gmVLgN;jP
z<eWDw^K`r-fB>;yX?cYQT$0W3if{?_svK3oLhFnt8+p~dsD2Av;bsH0U&RQk8u@oJ
zXlK7tjYS#NEma_{LYno;6s|C!l`ZHg2EkC1ogH<RfpM~fW1JlZjk><80B%0>pgv9M
zys!$#yxPqaZ>`aU*!2iK%&o!!w8?RIBH6|KV_)GdyOUN<HlBMGYdSZ<-!pJkcHp6c
zt7bvrKRQmwBn{cTY-;3H*2;8C(MoG-$H2rZ-84fWtqe_9Tym((kf1aW5FliWfb4u2
z?y{6C>9oA&idP6$x6Sh^3tZ()1Zp@HF1cR8Kd$hYHCip?+KzH>J?y|3E|ZioS+wD`
z4D#Za^=ZAbEMEek?Wsl0^gN>k(v4m#)zT6J!#`h>mwp>ssTzqbUQr>j8Ad9a6J_G6
z{oeN+KdQR{MN7{s)B`coRf=sNT)}iE8}v*w=uY(tlt$2RANnWh@c3&*MnOu4XAm*e
zhH``^ugI?~T6y&3v#+FnPF225<SgBLZt}DUT&^1O>U=UCMblNr<18FnH}x^bF$;WI
zMuk`5R{Yw3Y??IE%FHWcI%q!Pl{Z~M#jBPq(l)?qBoN^0F#W<JImm1xa#tyx7h|vG
z&NtGNz>9xNO^|ryqYWb9Rjv_Q?>9fGcxCJmdye#XjF@b*UctXTl;W6`)RsbXmN0bJ
zBTOYd*>j}7JB+0)Xgt65++XAn)T}S)x1wq!)zfouPT%f#ohDy7@ITMc19YX8U!1Jl
z#%Xl=J-^OdBa}<oKe6;KdZqyYqKizFDPF#mA`_?&%T?4(aIAh?=^$p&O$XpQc5?_7
zjB}0@o_O{XL-Z!EDy@7vKidJ=Dr4tQKZlUPF_BkcmATy?jkeUr^jRVSe^$2grU_u3
zZ!dkiOHBH+7YrE|9`-J|>a?-xNGtITts!2~aVAnJ6`@rHVGBo))4fmLCGo*kmv__w
zhAp|1b{sTm<zZe4g3Xw{Rx(_gS4^*Tr~uLmznQ(9(DfW#{s^Jl9+2u>(=nL5C&(=!
zqP3(1n4xIDlKqtZC(g?)+<CN<qU-B6M?pj-IS}n--5Y+Y8c8cd+2F7F6l_YZME(K$
zKk2<)e0A{(CA<8D^mq*OicJ^uicI%VWdtQ0eO~F)Ym!$PD983!01#k0E1;}v^#e4G
z%fu`A*ZGc0OsTCu#`_&an&uGL9Qrw?U~`^7pdKGuaEmpq@k%VfrR9T;7qI)0w|_+=
zv!02|ltd4eg$G?a){v5TEUwF%v~IXK{Z^*f;j#P(pf5&a_lJR6X$yc?Uw*OlimRJf
zXViRr3XI~FGaUv#@f<qc#dH#xEKp`4fB{}D-{TY$a4qqQmZypxOf>W>!47o+^lbWy
z@k*bgq3vKO%+qZE4I@J<%X$5DyJ_wWNkOL^(i(AOjbBiALe}!JYiL_1Oi3V)&vxIl
zdUnt1x%$m4fU9`u5!YM?=#g1Z4I~#%3JT!-8o}Q5vQawK!%Tlz7I0fgjxg!d-vw+M
zR}ZhuEER-u#;X~x2%~r<C%AsEt_?y~Po#X3pRr(jhTD4jHXg3dWkDx`l+&@fDbNfX
zS+{|}O+co_-j#dIM2Q*#xXW+DayN$d-h{c>J<&HpvXEfS4BbC_8BJf)8Lwi@c%^YI
z@QSojU(SWD+bIp9IUKAY%MjesV0S*P!7~?#&n+}^I2r>z;z{Lwo8=1DZCRsFoxqQX
zuxsfQj9^?@fjh+)5h^41yCq}mTA%?ecOeN<Hlc?uEd>s&kj!|cFymE%l<k`16<-q+
ziY%@VGOx9EGp*6XL3Jw_!wiivT(1GeHmf#-8%{moLOPJf3js5xdHNZU0lx;yP!S~r
zxC7xdZ6vs|1MU)5Dk$xYSK~3`RfsFkD}NpVJ^97;y8X(4rj?$sht?xH%I%<8RX3ru
zYdHMERsPka7CMj7!v?6q)=UM92*d>w6Ad<efSl~K9kRymm3w?5BS`N$_IUOq4eUmc
zH_*;5gP8GZ#;XplI$i~9B2_{LDt=v>F$mf$r-^p#=ROTO4-*-K5w;HfDFPFHSED_k
z?v7PW)J-<ofT<aDU6}Z^R_HbK%DNj=!KsnW2x<ixUXsscoAK(BV#ce2%f>7C$73KS
z6y+)zfCt-LgCOWv0cuO>Q-O;%3Tmj)OV=8m0iQ8AxYa52hvhMJ+_QT2`n(XcbE*6!
zDOuisKEcF-WPQF>OhAjr;@ya$c;sxAR>GkxN|Wif<HE?}REXbdS-^JjN@K>W8Z%yL
zTtZ&ylgfPSki=Z|?KU=sR%>+$fUlV5w@G=8*6eO%t2c54Zcz{h88B<jzd_1s_>oGL
zF!ae=gkZ>1wuR%T`!OLSw#>jvc1E$4EAR-w?4v`z&4G<GMwPaOR~j>3NqB%6uXNxx
z@@kBM+$u?DbcJk!*YU@-fo4E|nbzB=kHvK;zm$1b^-+Xb@uktV)6=++GIn)Pe|-_&
z6&h1q1At$rug8CDUZFzIhQa{aBddfDg7V@rb4GA`+;z8`S1trG;}v1XD~C(PD}UZV
zskurBeCB#<5YS4ueF#9j>&-#h2`#9qCquVu_<G!Kv5?nv9pH9or#cbIj>ponR9wMb
z>i2=vmbQgTjd<5<bxF{7bHr$jtu(>zs(&JEfk%2V4&!+hV#X_d>M-LKVjFp-PYg3c
z#dU$UR*dj7&$ODG$1a&rY#M%olVN5ARh(i$LTgzHpkwY?JuBG-V_l;pgOH_e9ip8P
zDPE_XKKE$%Q$QU!)pT+UL;}EjGA`9N@hZfOS2bq5D%f6L@d*QJE`q8ZR~~ZRcp?#;
z$BW3@9rN!2i9uVh+7CYkBb1S!>pT^is>r}pIqp2;12*dx;*p%I-0|%h!bLP46+jl7
z2j70cwxC<sddwI-hXMqaw}9zV*!eM?YFVcPrv)|m)3Fw|jaL~nUh%<<SC^Gn=0t&$
z{?gg+=s<uZ#NYzyf|6hP_k0WtIOym?)$oR{><(;j(;q;O`l^Kjs^#<-D!*fa8be;A
zs~4(Ut20tOXV4(`HtOuQ9eUQ*pRzfOc}GOh^H3}{%`1Q`)y;U-$Bb8k?c`Mo%B`+<
zZMuH_KFLW^Kd{zTWina4-Ej>+SE@KY2rd{85j-kF31y(Z;bi*A!3~%r;iy(GFu|l|
z<m(7fPU*moQio1|Tb~-_TUtw3x1E1Tj`f^taG(Z2?UL^!{**<YfS9X$!nqYadF12z
znFAtMWb3>dgBh;?GhP8M39obzW2BbrMrBiS<Av*$c{{K7%YKNOZTffwz#?MG04}vC
z@dIr}>eb)9tLK1-_)?haFdDiTLRq#0PXzX>8CerU(-zkm0D}v2vTW~q1=ONvy3s(h
zSO-mL+QJrj)q&9$9eL<RhZ(PCywdQzY7GL2>XIH_ylJFig6)n0W#?xTUS+|i;eoxb
zj0_iJ;Eb*TW2RnLLgbR@#pyA_DWmogYG`WKj>(}j500EV4YDW3;u`b>J>RTnqku4R
zoZ7gS8sgdZ^Qw)YnP$AonDL6S4ZJcZ8L`!JHTtF(zfupRNH5aRJE`sC6(UOirlCCo
zpaS#iT`(YrECBb3)f)E(DI${*sS#u}I4A+aRb;rAoqwTq=|z%eJMpxb-H1>gQ?$^y
zac~t$nyi?somb1GTj7;N^Sq)17P}d*;9$n9gj}R;;}r*aEUt^Dww5+Dm@a0!V;jNk
z{5&0~G9f=YFk^yl$f_kmpF&$-zu^Ve;F7qz_B9^GGGuB~`js8lq;1L^$GRt2o<Y6>
z8k7Y<v6=DQqsA}RIE?AcO>Bx+fH9G$#*9}pUQNX-{x240tU$6O*xJQ`c9I4dg~fGA
zp){>R$SnpmFpPW940?#rUqJ{b5RJBXt1~i;=*iL6QCpI|k}uy|R?WwwUQu$b%ZckM
zbj;WU(Nv~Rl7i8NoR^@*8I2jQwhJ>}X<Qjz)w#Nwj48T?rk$Z0Bo(m@+oL<Axbg_<
z_8tS6SoL4p(&cY???Nos%;Nzqx4->_ju8%ezB$CC%C<P48nGM`pnF%VA>gjsP%~aR
z%y`wpHNz`&G6bfPJRS;*<;0r@6DSZzmQi<M>2&KA;z10K*qm2gypA2&E+#^|r=?m{
z5oA_1I1}Nz*XwIFZ<<WfuqENwEM&H&E9KZAH%dP*?^w_!ZtHq}1c`UPZk`r1UNL68
zx|(@4Rx6>&!4W+eeifi9tjA=`tQt@1;%<5fbrY_U-;Ijl5~|kP9Ktt0#$eEkan;nr
z;6n8^8^C!tBd1QLUEFY5wHi1k%&?J(cQE5sA2VKU4wr;ia<mC<K~6j2?_{G4cT^77
z3<>HXqi&c!WT=N*!erghG*vB3lT0?GROT(*EjJrOo*_t$cqnEHLX*@^jeds6UI4^l
zBkXFw2d51J$;N$VYdyJkNm4G+RBOho8Lvj-YUh=ld(a>-;13TC6fJNA(`y;!)PW~2
zwV7mmi)+}xc2QHq&pWWOgIpv~UgoGV(rzJkRX-RVq^25P5WWY;Xq6|i*|s|{PvVDb
nVFoi^4PnMB#?{5EqbL7=ag?Ywm(qtO00000NkvXXu0mjfrCBth

literal 0
HcmV?d00001

diff --git a/docs/img/blog/todomvc.png b/docs/img/blog/todomvc.png
new file mode 100644
index 0000000000000000000000000000000000000000..9c03bc0f6225ee71a97e4ae34e36e4dbd0229704
GIT binary patch
literal 52203
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

literal 0
HcmV?d00001

diff --git a/docs/img/blog/xreact.png b/docs/img/blog/xreact.png
new file mode 100644
index 0000000000000000000000000000000000000000..59fbb6f22ae48a63b1b10f44525ecf92a2b974a9
GIT binary patch
literal 7913
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
JDk+no{{apE4hsMP

literal 0
HcmV?d00001


From ac5320e8871e87a01d22a69e2d9dc1ab7f781515 Mon Sep 17 00:00:00 2001
From: Ben Alpert <spicyjalapeno@gmail.com>
Date: Wed, 19 Jun 2013 17:26:29 -0700
Subject: [PATCH 37/94] Remove textContent tests; they break in phantomjs

---
 src/core/__tests__/ReactDOMTextarea-test.js | 19 +------------------
 1 file changed, 1 insertion(+), 18 deletions(-)

diff --git a/src/core/__tests__/ReactDOMTextarea-test.js b/src/core/__tests__/ReactDOMTextarea-test.js
index 0e600625c6..0ed7417d6a 100644
--- a/src/core/__tests__/ReactDOMTextarea-test.js
+++ b/src/core/__tests__/ReactDOMTextarea-test.js
@@ -19,8 +19,6 @@
 
 "use strict";
 
-var mocks = require('mocks');
-
 describe('ReactDOMTextarea', function() {
   var React;
   var ReactTestUtils;
@@ -29,25 +27,12 @@ describe('ReactDOMTextarea', function() {
   beforeEach(function() {
     React = require('React');
     ReactTestUtils = require('ReactTestUtils');
-    getTextContentAccessor = require('getTextContentAccessor');
   });
 
-  it("should update value and not update textContent", function() {
-    var textContentAccessor = getTextContentAccessor();
+  it("should update value", function() {
     var stub = ReactTestUtils.renderIntoDocument(<textarea>giraffe</textarea>);
     var node = stub.getDOMNode();
 
-    var nodeText = node[textContentAccessor];
-    var nodeTextSetter = mocks.getMockFunction();
-    Object.defineProperty(node, textContentAccessor, {
-      get: function() {
-        return nodeText;
-      },
-      set: nodeTextSetter.mockImplementation(function(newText) {
-        nodeText = newText;
-      })
-    });
-
     expect(node.value).toEqual('giraffe');
 
     stub.replaceProps({ children: 'gorilla' });
@@ -64,8 +49,6 @@ describe('ReactDOMTextarea', function() {
 
     stub.replaceProps({ content: 'eggplant' });
     expect(node.value).toEqual('eggplant');
-
-    expect(nodeTextSetter.mock.calls.length).toBe(0);
   });
 
   it("should throw with multiple or invalid children", function() {

From 4c97ffee348ada09749a262a7ca22a7853551225 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Paul=20O=E2=80=99Shannessy?= <paul@oshannessy.com>
Date: Thu, 20 Jun 2013 16:51:21 -0700
Subject: [PATCH 38/94] Bring in Facebook's requestAnimationFrame module

---
 src/vendor/core/requestAnimationFrame.js | 37 ++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 src/vendor/core/requestAnimationFrame.js

diff --git a/src/vendor/core/requestAnimationFrame.js b/src/vendor/core/requestAnimationFrame.js
new file mode 100644
index 0000000000..e71052efbf
--- /dev/null
+++ b/src/vendor/core/requestAnimationFrame.js
@@ -0,0 +1,37 @@
+/**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @providesModule requestAnimationFrame
+ */
+
+var emptyFunction = require('emptyFunction');
+
+var requestAnimationFrame =
+  window.requestAnimationFrame       ||
+  window.webkitRequestAnimationFrame ||
+  window.mozRequestAnimationFrame    ||
+  window.oRequestAnimationFrame      ||
+  window.msRequestAnimationFrame     ||
+  function(callback) {
+    // Browsers which don't support requestAnimationFrame are likely running on
+    // older hardware, so it's not reasonable to expect 60FPS animations out of
+    // them. 30FPS (33.3ms per frame) is more reasonable.
+    return window.setTimeout(callback, 33);
+  };
+
+// Works around a rare bug in Safari 6 where the first request is never invoked.
+requestAnimationFrame(emptyFunction);
+
+module.exports = requestAnimationFrame;

From 18352090e7d334bbba203761d9884ca1a5742022 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Paul=20O=E2=80=99Shannessy?= <paul@oshannessy.com>
Date: Thu, 20 Jun 2013 18:30:30 -0700
Subject: [PATCH 39/94] Blogpost & changelog for v0.3.3

---
 docs/_posts/2013-06-21-react-v0-3-3.md | 24 ++++++++++++++++++++++++
 docs/downloads.md                      |  2 ++
 2 files changed, 26 insertions(+)
 create mode 100644 docs/_posts/2013-06-21-react-v0-3-3.md

diff --git a/docs/_posts/2013-06-21-react-v0-3-3.md b/docs/_posts/2013-06-21-react-v0-3-3.md
new file mode 100644
index 0000000000..668c83de1a
--- /dev/null
+++ b/docs/_posts/2013-06-21-react-v0-3-3.md
@@ -0,0 +1,24 @@
+---
+title: "React v0.3.3"
+layout: post
+author: Paul O'Shannessy
+---
+
+We have a ton of great stuff coming in v0.4, but in the meantime we're releasing v0.3.3. This release addresses some small issues people were having and simplifies our tools to make them easier to use.
+
+
+## react-tools
+
+* Upgrade Commoner so `require` statements are no longer relativized when passing through the transformer. This was a feature needed when building React, but doesn't translate well for other consumers of `bin/jsx`.
+* Upgraded our dependencies on Commoner and Recast so they use a different directory for their cache.
+* Freeze our esprima dependency.
+
+
+## React
+
+* Allow reusing the same DOM node to render different components. e.g. `React.renderComponent(<div/>, domNode); React.renderComponent(<span/>, domNode);` will work now.
+
+
+## JSXTransformer
+
+* Improved the in-browser transformer so that transformed scripts will execute in the expected scope. The allows components to be defined and used from separate files.
diff --git a/docs/downloads.md b/docs/downloads.md
index d35ff4dbd2..2b2a9ad556 100644
--- a/docs/downloads.md
+++ b/docs/downloads.md
@@ -49,6 +49,8 @@ $ npm install -g react-tools
 
 ## Release Notes
 
+**0.3.3** Upgrade `react-tools` dependencies, improve in-browser JSX transformer, make `React.renderComponent` more versatile. [Details...](blog/2013/06/20/react-v0-3-3.html)
+
 **0.3.2** Improve compatibility of JSX Transformer; make `react-tools` compatible with [browserify](https://github.com/substack/node-browserify)
 
 **0.3.1** Fix `react-tools` module

From 36a724fecaed3c52ce8140683f452524934caceb Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 21 Jun 2013 13:48:48 -0700
Subject: [PATCH 40/94] Add `reactComponentExpect#toBeComponentOfType`

This adds a `toBeComponentOfType` method to `reactComponentExpect`. Now that we are injecting composite native components, `toBeDOMComponentWithTag` will not suffice and should be deprecated.
---
 src/core/ReactDOM.js                                 |  5 +++--
 .../ReactCompositeComponentTransferProps-test.js     |  6 +++---
 src/test/ReactTestUtils.js                           |  8 ++++++++
 src/test/reactComponentExpect.js                     | 12 ++++++++++++
 4 files changed, 26 insertions(+), 5 deletions(-)

diff --git a/src/core/ReactDOM.js b/src/core/ReactDOM.js
index 2fe78e99a7..b1882b3be0 100644
--- a/src/core/ReactDOM.js
+++ b/src/core/ReactDOM.js
@@ -41,15 +41,16 @@ var objMapKeyVal = require('objMapKeyVal');
  */
 function createDOMComponentClass(tag, omitClose) {
   var Constructor = function() {};
-
   Constructor.prototype = new ReactNativeComponent(tag, omitClose);
   Constructor.prototype.constructor = Constructor;
 
-  return function(props, children) {
+  var ConvenienceConstructor = function(props, children) {
     var instance = new Constructor();
     instance.construct.apply(instance, arguments);
     return instance;
   };
+  ConvenienceConstructor.componentConstructor = Constructor;
+  return ConvenienceConstructor;
 }
 
 /**
diff --git a/src/core/__tests__/ReactCompositeComponentTransferProps-test.js b/src/core/__tests__/ReactCompositeComponentTransferProps-test.js
index 47cc7455af..70c7e27532 100644
--- a/src/core/__tests__/ReactCompositeComponentTransferProps-test.js
+++ b/src/core/__tests__/ReactCompositeComponentTransferProps-test.js
@@ -52,7 +52,7 @@ describe('ReactCompositeComponent-transferProps', function() {
 
     reactComponentExpect(instance)
       .expectRenderedChild()
-        .toBeDOMComponentWithTag('input')
+        .toBeComponentOfType(React.DOM.input)
         .scalarPropsEqual({
           className: 'textinput',
           style: {display: 'block'},
@@ -67,7 +67,7 @@ describe('ReactCompositeComponent-transferProps', function() {
 
     reactComponentExpect(instance)
       .expectRenderedChild()
-        .toBeDOMComponentWithTag('input')
+        .toBeComponentOfType(React.DOM.input)
         .scalarPropsEqual({placeholder: 'Type here...'});
   });
 
@@ -81,7 +81,7 @@ describe('ReactCompositeComponent-transferProps', function() {
 
     reactComponentExpect(instance)
       .expectRenderedChild()
-        .toBeDOMComponentWithTag('input')
+        .toBeComponentOfType(React.DOM.input)
         .scalarPropsEqual({
           className: 'textinput hidden_elem',
           style: {
diff --git a/src/test/ReactTestUtils.js b/src/test/ReactTestUtils.js
index 95651d5c90..e703472ea8 100644
--- a/src/test/ReactTestUtils.js
+++ b/src/test/ReactTestUtils.js
@@ -45,6 +45,14 @@ var ReactTestUtils = {
     return React.renderComponent(instance, div);
   },
 
+  isComponentOfType: function(inst, type) {
+    return !!(
+      inst &&
+      ReactComponent.isValidComponent(inst) &&
+      inst.constructor === type.componentConstructor
+    );
+  },
+
   isDOMComponent: function(inst) {
     return !!(inst &&
               ReactComponent.isValidComponent(inst) &&
diff --git a/src/test/reactComponentExpect.js b/src/test/reactComponentExpect.js
index 0a359fe2d2..dc664075bc 100644
--- a/src/test/reactComponentExpect.js
+++ b/src/test/reactComponentExpect.js
@@ -104,6 +104,14 @@ mergeInto(reactComponentExpect.prototype, {
 
   // Matchers ------------------------------------------------------------------
 
+  toBeComponentOfType: function(convenienceConstructor) {
+    expect(ReactTestUtils.isComponentOfType(
+      this.instance(),
+      convenienceConstructor
+    )).toBe(true);
+    return this;
+  },
+
   /**
    * A component that is created with React.createClass. Just duck typing
    * here.
@@ -149,6 +157,10 @@ mergeInto(reactComponentExpect.prototype, {
     return this;
   },
 
+  /**
+   * @deprecated
+   * @see toBeComponentOfType
+   */
   toBeDOMComponentWithTag: function(tag) {
     this.toBeDOMComponent();
     expect(this.instance().tagName).toBe(tag.toUpperCase());

From 2bc2b52eaa7f541dd3ad30ede41e2a8dba74d9c8 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 21 Jun 2013 13:53:25 -0700
Subject: [PATCH 41/94] Allow accessing siblings by ref

This makes it possible to write a wider range of components without
depending on internal implementations.
---
 src/core/ReactComponent.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/core/ReactComponent.js b/src/core/ReactComponent.js
index 530a6f9c66..d312881068 100644
--- a/src/core/ReactComponent.js
+++ b/src/core/ReactComponent.js
@@ -564,6 +564,22 @@ var ReactComponent = {
      */
     isOwnedBy: function(owner) {
       return this.props[OWNER] === owner;
+    },
+
+    /**
+     * Gets another component, that shares the same owner as this one, by ref.
+     *
+     * @param {string} ref of a sibling Component.
+     * @return {?ReactComponent} the actual sibling Component.
+     * @final
+     * @internal
+     */
+    getSiblingByRef: function(ref) {
+      var owner = this.props[OWNER];
+      if (!owner || !owner.refs) {
+        return null;
+      }
+      return owner.refs[ref];
     }
 
   }

From 191c0dec32ee22ec833c2afc0107058f66982a0f Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 21 Jun 2013 16:01:16 -0700
Subject: [PATCH 42/94] Consolidate ReactDOMNodeCache and getDOMNodeID into
 ReactID.

When we move away from using the "id" attribute to identify
React-generated elements, we will need the cache (formerly
ReactDOMNodeCache) to be tied much more closely to the code that looks
elements up by ID (getDOMNodeID) and sets element IDs, since the magic of
document.getElementById will no longer be available.

The priming functions are going to come in handy when we create new DOM
fragments in mountComponent.

For backwards compatibility, the ReactDOMNodeCache and getDOMNodeID
modules still exist, but they are implemented entirely in terms of
functions exported from ReactID.
---
 src/core/ReactDOMNodeCache.js |  70 ++-----------------
 src/core/ReactID.js           | 128 ++++++++++++++++++++++++++++++++++
 src/dom/getDOMNodeID.js       |  21 ++----
 3 files changed, 136 insertions(+), 83 deletions(-)
 create mode 100644 src/core/ReactID.js

diff --git a/src/core/ReactDOMNodeCache.js b/src/core/ReactDOMNodeCache.js
index eaec6501ba..908c2ddbcd 100644
--- a/src/core/ReactDOMNodeCache.js
+++ b/src/core/ReactDOMNodeCache.js
@@ -19,70 +19,8 @@
 
 "use strict";
 
-var ExecutionEnvironment = require('ExecutionEnvironment');
-var ReactMount = require('ReactMount');
+var ReactID = require('ReactID');
 
-var invariant = require('invariant');
-
-var nodeCache = {};
-
-/**
- * DOM node cache only intended for use by React. Placed into a shared module so
- * that both read and write utilities may benefit from a shared cache.
- *
- * @internal
- */
-var ReactDOMNodeCache = {
-
-  /**
-   * Finds the node with the supplied React-generated DOM ID.
-   *
-   * @param {string} id A React-generated DOM ID.
-   * @return {?DOMElement} DOM node with the suppled `id`.
-   * @internal
-   */
-  getNodeByID: function(id) {
-    invariant(
-      ExecutionEnvironment.canUseDOM,
-      'getDOMNode(): The DOM is not supported in the current environment.'
-    );
-    if (!nodeCache[id]) {
-      nodeCache[id] =
-        document.getElementById(id) ||
-        ReactMount.findReactRenderedDOMNodeSlow(id);
-    }
-    return nodeCache[id];
-  },
-
-  /**
-   * Purges the supplied ID from cache.
-   *
-   * @param {string} id A React-generated DOM ID.
-   * @internal
-   */
-  purgeID: function(id) {
-    nodeCache[id] = null;
-  },
-
-  /**
-   * Purges the entire node cache used for fast ID lookups.
-   *
-   * This implementation is aggressive with purging because the bookkeeping
-   * associated with doing fine-grained deletes from the cache may outweight the
-   * benefits of the cache.
-   *
-   * The heuristic used to purge is 'any time anything is deleted'. Typically
-   * this means that a large amount of content is being replaced and several
-   * elements would need purging regardless. This is also when applications are
-   * less likely to be in the middle of "smooth operations" such as animations
-   * or scrolling.
-   *
-   * @internal
-   */
-  purgeEntireCache: function() {
-    nodeCache = {};
-  }
-
-};
-
-module.exports = ReactDOMNodeCache;
+exports.getNodeByID = ReactID.getNode;
+exports.purgeID = ReactID.purgeID;
+exports.purgeEntireCache = ReactID.purgeEntireCache;
diff --git a/src/core/ReactID.js b/src/core/ReactID.js
new file mode 100644
index 0000000000..313ccebefe
--- /dev/null
+++ b/src/core/ReactID.js
@@ -0,0 +1,128 @@
+/**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @providesModule ReactID
+ * @typechecks
+ */
+
+"use strict";
+
+var ReactMount = require('ReactMount');
+var ATTR_NAME = 'id';
+var nodeCache = {};
+
+/**
+ * Accessing node[ATTR_NAME] or calling getAttribute(ATTR_NAME) on a form
+ * element can return its control whose name or ID equals ATTR_NAME. All
+ * DOM nodes support `getAttributeNode` but this can also get called on
+ * other objects so just return '' if we're given something other than a
+ * DOM node (such as window).
+ *
+ * @param {DOMElement|DOMWindow|DOMDocument} node DOM node.
+ * @returns {string} ID of the supplied `domNode`.
+ */
+function getID(node) {
+  if (node && node.getAttributeNode) {
+    var attributeNode = node.getAttributeNode(ATTR_NAME);
+    return attributeNode && attributeNode.value || '';
+  }
+
+  return '';
+}
+
+/**
+ * Sets the React-specific ID of the given node.
+ *
+ * @param {DOMElement} node The DOM node whose ID will be set.
+ * @param {string} id The value of the ID attribute.
+ */
+function setID(node, id) {
+  var oldID = getID(node);
+  if (oldID !== id) {
+    delete nodeCache[oldID];
+  }
+  node.setAttribute(ATTR_NAME, id);
+  nodeCache[id] = node;
+}
+
+/**
+ * Finds the node with the supplied React-generated DOM ID.
+ *
+ * @param {string} id A React-generated DOM ID.
+ * @return {?DOMElement} DOM node with the suppled `id`.
+ * @internal
+ */
+function getNode(id) {
+  if (!nodeCache.hasOwnProperty(id)) {
+    nodeCache[id] =
+      document.getElementById(id) || // TODO Quit using getElementById.
+      ReactMount.findReactRenderedDOMNodeSlow(id);
+  }
+
+  var node = nodeCache[id];
+  if (getID(node) === id) {
+    return node;
+  }
+
+  return null;
+}
+
+/**
+ * Efficiently finds all nodes with a React-specific ID and primes the
+ * cache so that getNode lookups take constant time.
+ *
+ * @param {DOMElement} root The root element to scan.
+ */
+function primeTree(root) {
+  var nodes = root.querySelectorAll
+    ? root.querySelectorAll('[' + ATTR_NAME + ']')
+    : root.getElementsByTagName('*');
+
+  for (var i = 0; i < nodes.length; ++i) {
+    prime(nodes.item(i));
+  }
+
+  prime(root);
+}
+
+function prime(node) {
+  var attributeNode = node.getAttributeNode(ATTR_NAME);
+  if (attributeNode) {
+    nodeCache[attributeNode.value] = node;
+  }
+}
+
+/**
+ * Causes the cache to forget about one React-specific ID.
+ *
+ * @param {string} id The ID to forget.
+ */
+function purgeID(id) {
+  delete nodeCache[id];
+}
+
+/**
+ * Clears the entire cache.
+ */
+function purgeEntireCache() {
+  nodeCache = {};
+}
+
+exports.getID = getID;
+exports.setID = setID;
+exports.getNode = getNode;
+exports.primeTree = primeTree;
+exports.purgeID = purgeID;
+exports.purgeEntireCache = purgeEntireCache;
diff --git a/src/dom/getDOMNodeID.js b/src/dom/getDOMNodeID.js
index f9632d8de5..dddd6fadee 100644
--- a/src/dom/getDOMNodeID.js
+++ b/src/dom/getDOMNodeID.js
@@ -19,22 +19,9 @@
 
 "use strict";
 
-/**
- * Accessing "id" or calling getAttribute('id') on a form element can return its
- * control whose name or ID is "id". All DOM nodes support `getAttributeNode`
- * but this can also get called on other objects so just return '' if we're
- * given something other than a DOM node (such as window).
- *
- * @param {DOMElement|DOMWindow|DOMDocument} domNode DOM node.
- * @returns {string} ID of the supplied `domNode`.
- */
-function getDOMNodeID(domNode) {
-  if (domNode.getAttributeNode) {
-    var attributeNode = domNode.getAttributeNode('id');
-    return attributeNode && attributeNode.value || '';
-  } else {
-    return '';
-  }
-}
+var ReactID = require('ReactID');
 
+function getDOMNodeID(domNode) {
+  return ReactID.getID(domNode);
+}
 module.exports = getDOMNodeID;

From 1839bcf109a598a45ba45214cde02d25c33f2938 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 21 Jun 2013 16:01:21 -0700
Subject: [PATCH 43/94] Replace uses of ReactDOMNodeCache and getDOMNodeID with
 ReactID.

Also removed some unnecessary calls to `document.getElementById`, which
will eventually cease to work for React-specific IDs.

This clears the way for the deprecation of `ReactDOMNodeCache` and
`getDOMNodeID`.
---
 src/core/ReactComponent.js                    |  6 ++---
 src/core/ReactDOMIDOperations.js              | 22 +++++++++----------
 src/core/ReactEventTopLevelCallback.js        |  4 ++--
 src/core/ReactInputSelection.js               |  6 ++++-
 src/core/ReactInstanceHandles.js              |  4 ++--
 .../__tests__/ReactCompositeComponent-test.js |  4 +++-
 src/core/__tests__/ReactDOM-test.js           |  7 +++---
 .../__tests__/ReactDOMIDOperations-test.js    | 10 ++++-----
 src/eventPlugins/EnterLeaveEventPlugin.js     |  6 ++---
 src/test/ReactTestUtils.js                    |  4 ++--
 10 files changed, 40 insertions(+), 33 deletions(-)

diff --git a/src/core/ReactComponent.js b/src/core/ReactComponent.js
index d312881068..f4333af4a6 100644
--- a/src/core/ReactComponent.js
+++ b/src/core/ReactComponent.js
@@ -22,7 +22,7 @@
 
 var ReactCurrentOwner = require('ReactCurrentOwner');
 var ReactDOMIDOperations = require('ReactDOMIDOperations');
-var ReactDOMNodeCache = require('ReactDOMNodeCache');
+var ReactID = require('ReactID');
 var ReactMount = require('ReactMount');
 var ReactOwner = require('ReactOwner');
 var ReactReconcileTransaction = require('ReactReconcileTransaction');
@@ -285,7 +285,7 @@ var ReactComponent = {
         this.isMounted(),
         'getDOMNode(): A component must be mounted to have a DOM node.'
       );
-      return ReactDOMNodeCache.getNodeByID(this._rootNodeID);
+      return ReactID.getNode(this._rootNodeID);
     },
 
     /**
@@ -440,7 +440,7 @@ var ReactComponent = {
       if (props.ref != null) {
         ReactOwner.removeComponentAsRefFrom(this, props.ref, props[OWNER]);
       }
-      ReactDOMNodeCache.purgeID(this._rootNodeID);
+      ReactID.purgeID(this._rootNodeID);
       this._rootNodeID = null;
       this._lifeCycleState = ComponentLifeCycle.UNMOUNTED;
     },
diff --git a/src/core/ReactDOMIDOperations.js b/src/core/ReactDOMIDOperations.js
index 531de5338a..f95fc2837a 100644
--- a/src/core/ReactDOMIDOperations.js
+++ b/src/core/ReactDOMIDOperations.js
@@ -24,7 +24,7 @@
 var CSSPropertyOperations = require('CSSPropertyOperations');
 var DOMChildrenOperations = require('DOMChildrenOperations');
 var DOMPropertyOperations = require('DOMPropertyOperations');
-var ReactDOMNodeCache = require('ReactDOMNodeCache');
+var ReactID = require('ReactID');
 
 var getTextContentAccessor = require('getTextContentAccessor');
 var invariant = require('invariant');
@@ -66,7 +66,7 @@ var ReactDOMIDOperations = {
    * @internal
    */
   updatePropertyByID: function(id, name, value) {
-    var node = ReactDOMNodeCache.getNodeByID(id);
+    var node = ReactID.getNode(id);
     invariant(
       !INVALID_PROPERTY_ERRORS.hasOwnProperty(name),
       'updatePropertyByID(...): %s',
@@ -84,7 +84,7 @@ var ReactDOMIDOperations = {
    * @internal
    */
   deletePropertyByID: function(id, name, value) {
-    var node = ReactDOMNodeCache.getNodeByID(id);
+    var node = ReactID.getNode(id);
     invariant(
       !INVALID_PROPERTY_ERRORS.hasOwnProperty(name),
       'updatePropertyByID(...): %s',
@@ -121,7 +121,7 @@ var ReactDOMIDOperations = {
    * @internal
    */
   updateStylesByID: function(id, styles) {
-    var node = ReactDOMNodeCache.getNodeByID(id);
+    var node = ReactID.getNode(id);
     CSSPropertyOperations.setValueForStyles(node, styles);
   },
 
@@ -133,7 +133,7 @@ var ReactDOMIDOperations = {
    * @internal
    */
   updateInnerHTMLByID: function(id, html) {
-    var node = ReactDOMNodeCache.getNodeByID(id);
+    var node = ReactID.getNode(id);
     // HACK: IE8- normalize whitespace in innerHTML, removing leading spaces.
     // @see quirksmode.org/bugreports/archives/2004/11/innerhtml_and_t.html
     node.innerHTML = (html && html.__html || '').replace(/^ /g, '&nbsp;');
@@ -147,7 +147,7 @@ var ReactDOMIDOperations = {
    * @internal
    */
   updateTextContentByID: function(id, content) {
-    var node = ReactDOMNodeCache.getNodeByID(id);
+    var node = ReactID.getNode(id);
     node[textContentAccessor] = content;
   },
 
@@ -160,9 +160,9 @@ var ReactDOMIDOperations = {
    * @see {Danger.dangerouslyReplaceNodeWithMarkup}
    */
   dangerouslyReplaceNodeWithMarkupByID: function(id, markup) {
-    var node = ReactDOMNodeCache.getNodeByID(id);
+    var node = ReactID.getNode(id);
     DOMChildrenOperations.dangerouslyReplaceNodeWithMarkup(node, markup);
-    ReactDOMNodeCache.purgeEntireCache();
+    ReactID.purgeEntireCache();
   },
 
   /**
@@ -170,13 +170,13 @@ var ReactDOMIDOperations = {
    *       Detect if any elements were removed instead of blindly purging.
    */
   manageChildrenByParentID: function(parentID, domOperations) {
-    var parent = ReactDOMNodeCache.getNodeByID(parentID);
+    var parent = ReactID.getNode(parentID);
     DOMChildrenOperations.manageChildren(parent, domOperations);
-    ReactDOMNodeCache.purgeEntireCache();
+    ReactID.purgeEntireCache();
   },
 
   setTextNodeValueAtIndexByParentID: function(parentID, index, value) {
-    var parent = ReactDOMNodeCache.getNodeByID(parentID);
+    var parent = ReactID.getNode(parentID);
     DOMChildrenOperations.setTextNodeValueAtIndex(parent, index, value);
   }
 
diff --git a/src/core/ReactEventTopLevelCallback.js b/src/core/ReactEventTopLevelCallback.js
index fde97acc15..be70785073 100644
--- a/src/core/ReactEventTopLevelCallback.js
+++ b/src/core/ReactEventTopLevelCallback.js
@@ -23,7 +23,7 @@ var ExecutionEnvironment = require('ExecutionEnvironment');
 var ReactEventEmitter = require('ReactEventEmitter');
 var ReactInstanceHandles = require('ReactInstanceHandles');
 
-var getDOMNodeID = require('getDOMNodeID');
+var ReactID = require('ReactID');
 var getEventTarget = require('getEventTarget');
 
 /**
@@ -76,7 +76,7 @@ var ReactEventTopLevelCallback = {
       var topLevelTarget = ReactInstanceHandles.getFirstReactDOM(
         getEventTarget(nativeEvent)
       ) || ExecutionEnvironment.global;
-      var topLevelTargetID = getDOMNodeID(topLevelTarget) || '';
+      var topLevelTargetID = ReactID.getID(topLevelTarget) || '';
       ReactEventEmitter.handleTopLevel(
         topLevelType,
         topLevelTarget,
diff --git a/src/core/ReactInputSelection.js b/src/core/ReactInputSelection.js
index 2abd7ab6f0..056db55119 100644
--- a/src/core/ReactInputSelection.js
+++ b/src/core/ReactInputSelection.js
@@ -27,6 +27,10 @@ function getActiveElement() {
   }
 }
 
+function isInDocument(node) {
+  return document.documentElement.contains(node);
+}
+
 /**
  * @ReactInputSelection: React input selection module. Based on Selection.js,
  * but modified to be suitable for react and has a couple of bug fixes (doesn't
@@ -64,7 +68,7 @@ var ReactInputSelection = {
     var priorFocusedElem = priorSelectionInformation.focusedElem;
     var priorSelectionRange = priorSelectionInformation.selectionRange;
     if (curFocusedElem !== priorFocusedElem &&
-        document.getElementById(priorFocusedElem.id)) {
+        isInDocument(priorFocusedElem)) {
       if (ReactInputSelection.hasSelectionCapabilities(priorFocusedElem)) {
         ReactInputSelection.setSelection(
           priorFocusedElem,
diff --git a/src/core/ReactInstanceHandles.js b/src/core/ReactInstanceHandles.js
index 8f26212864..d6a8df0941 100644
--- a/src/core/ReactInstanceHandles.js
+++ b/src/core/ReactInstanceHandles.js
@@ -19,7 +19,7 @@
 
 "use strict";
 
-var getDOMNodeID = require('getDOMNodeID');
+var ReactID = require('ReactID');
 var invariant = require('invariant');
 
 var SEPARATOR = '.';
@@ -250,7 +250,7 @@ var ReactInstanceHandles = {
       // Not a DOMElement, therefore not a React component
       return false;
     }
-    var id = getDOMNodeID(node);
+    var id = ReactID.getID(node);
     return id ? id.charAt(0) === SEPARATOR : false;
   },
 
diff --git a/src/core/__tests__/ReactCompositeComponent-test.js b/src/core/__tests__/ReactCompositeComponent-test.js
index 178edaee1d..5a6e9602bf 100644
--- a/src/core/__tests__/ReactCompositeComponent-test.js
+++ b/src/core/__tests__/ReactCompositeComponent-test.js
@@ -26,6 +26,7 @@ var React;
 var ReactCurrentOwner;
 var ReactProps;
 var ReactTestUtils;
+var ReactID;
 
 var cx;
 var reactComponentExpect;
@@ -39,6 +40,7 @@ describe('ReactCompositeComponent', function() {
     ReactCurrentOwner = require('ReactCurrentOwner');
     ReactProps = require('ReactProps');
     ReactTestUtils = require('ReactTestUtils');
+    ReactID = require('ReactID');
 
     MorphingComponent = React.createClass({
       getInitialState: function() {
@@ -160,7 +162,7 @@ describe('ReactCompositeComponent', function() {
     // rerender
     instance.setProps({renderAnchor: true, anchorClassOn: false});
     var anchorID = instance.getAnchorID();
-    var actualDOMAnchorNode = document.getElementById(anchorID);
+    var actualDOMAnchorNode = ReactID.getNode(anchorID);
     expect(actualDOMAnchorNode.className).toBe('');
   });
 
diff --git a/src/core/__tests__/ReactDOM-test.js b/src/core/__tests__/ReactDOM-test.js
index 3d20fd6e16..6068a81327 100644
--- a/src/core/__tests__/ReactDOM-test.js
+++ b/src/core/__tests__/ReactDOM-test.js
@@ -25,6 +25,7 @@ var React = require('React');
 var ReactDOM = require('ReactDOM');
 var ReactTestUtils = require('ReactTestUtils');
 var React = require('React');
+var ReactID = require('ReactID');
 
 describe('ref swapping', function() {
   // TODO: uncomment this test once we can run in phantom, which
@@ -60,7 +61,7 @@ describe('ref swapping', function() {
     var argDiv = ReactTestUtils.renderIntoDocument(
       ReactDOM.div(null, 'child')
     );
-    var argNode = document.getElementById(argDiv._rootNodeID);
+    var argNode = ReactID.getNode(argDiv._rootNodeID);
     expect(argNode.innerHTML).toBe('child');
   });
 
@@ -68,7 +69,7 @@ describe('ref swapping', function() {
     var conflictDiv = ReactTestUtils.renderIntoDocument(
       ReactDOM.div({children: 'fakechild'}, 'child')
     );
-    var conflictNode = document.getElementById(conflictDiv._rootNodeID);
+    var conflictNode = ReactID.getNode(conflictDiv._rootNodeID);
     expect(conflictNode.innerHTML).toBe('child');
   });
 
@@ -110,7 +111,7 @@ describe('ref swapping', function() {
         theBird: <div class="bird" />
       }
     });
-    var root = document.getElementById(myDiv._rootNodeID);
+    var root = ReactID.getNode(myDiv._rootNodeID);
     var dog = root.childNodes[0];
     expect(dog.className).toBe('bigdog');
   });
diff --git a/src/core/__tests__/ReactDOMIDOperations-test.js b/src/core/__tests__/ReactDOMIDOperations-test.js
index aa717aafd0..6353993cf5 100644
--- a/src/core/__tests__/ReactDOMIDOperations-test.js
+++ b/src/core/__tests__/ReactDOMIDOperations-test.js
@@ -23,11 +23,11 @@
 describe('ReactDOMIDOperations', function() {
   var DOMPropertyOperations = require('DOMPropertyOperations');
   var ReactDOMIDOperations = require('ReactDOMIDOperations');
-  var ReactDOMNodeCache = require('ReactDOMNodeCache');
+  var ReactID = require('ReactID');
   var keyOf = require('keyOf');
 
   it('should disallow updating special properties', function() {
-    spyOn(ReactDOMNodeCache, "getNodeByID");
+    spyOn(ReactID, "getNode");
     spyOn(DOMPropertyOperations, "setValueForProperty");
 
     expect(function() {
@@ -39,7 +39,7 @@ describe('ReactDOMIDOperations', function() {
     }).toThrow();
 
     expect(
-      ReactDOMNodeCache.getNodeByID.argsForCall[0][0]
+      ReactID.getNode.argsForCall[0][0]
     ).toBe('testID');
 
     expect(
@@ -49,7 +49,7 @@ describe('ReactDOMIDOperations', function() {
 
   it('should update innerHTML and special-case whitespace', function() {
     var stubNode = document.createElement('div');
-    spyOn(ReactDOMNodeCache, "getNodeByID").andReturn(stubNode);
+    spyOn(ReactID, "getNode").andReturn(stubNode);
 
     ReactDOMIDOperations.updateInnerHTMLByID(
       'testID',
@@ -57,7 +57,7 @@ describe('ReactDOMIDOperations', function() {
     );
 
     expect(
-      ReactDOMNodeCache.getNodeByID.argsForCall[0][0]
+      ReactID.getNode.argsForCall[0][0]
     ).toBe('testID');
 
     expect(stubNode.innerHTML).toBe('&nbsp;testContent');
diff --git a/src/eventPlugins/EnterLeaveEventPlugin.js b/src/eventPlugins/EnterLeaveEventPlugin.js
index c3fe3a8fe7..d01e032b99 100644
--- a/src/eventPlugins/EnterLeaveEventPlugin.js
+++ b/src/eventPlugins/EnterLeaveEventPlugin.js
@@ -25,7 +25,7 @@ var ExecutionEnvironment = require('ExecutionEnvironment');
 var ReactInstanceHandles = require('ReactInstanceHandles');
 var SyntheticMouseEvent = require('SyntheticMouseEvent');
 
-var getDOMNodeID = require('getDOMNodeID');
+var ReactID = require('ReactID');
 var keyOf = require('keyOf');
 
 var topLevelTypes = EventConstants.topLevelTypes;
@@ -85,8 +85,8 @@ var EnterLeaveEventPlugin = {
       return null;
     }
 
-    var fromID = from ? getDOMNodeID(from) : '';
-    var toID = to ? getDOMNodeID(to) : '';
+    var fromID = from ? ReactID.getID(from) : '';
+    var toID = to ? ReactID.getID(to) : '';
 
     var leave = SyntheticMouseEvent.getPooled(
       eventTypes.mouseLeave,
diff --git a/src/test/ReactTestUtils.js b/src/test/ReactTestUtils.js
index e703472ea8..56c43e0bce 100644
--- a/src/test/ReactTestUtils.js
+++ b/src/test/ReactTestUtils.js
@@ -21,8 +21,8 @@ var React = require('React');
 var ReactComponent = require('ReactComponent');
 var ReactEventEmitter = require('ReactEventEmitter');
 var ReactTextComponent = require('ReactTextComponent');
+var ReactID = require('ReactID');
 
-var ge = require('ge');
 var mergeInto = require('mergeInto');
 
 var topLevelTypes = EventConstants.topLevelTypes;
@@ -222,7 +222,7 @@ var ReactTestUtils = {
       ReactEventEmitter.TopLevelCallbackCreator.createTopLevelCallback(
         topLevelType
       );
-    var node = ge(reactRootID);
+    var node = ReactID.getNode(reactRootID);
     fakeNativeEvent.target = node;
     /* jsdom is returning nodes without id's - fixing that issue here. */
     node.id = reactRootID;

From 3373572e15c00b2dab9f005a85bb420fae107b2b Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 21 Jun 2013 16:01:26 -0700
Subject: [PATCH 44/94] Use ReactID.{get,set}ID instead of manipulating .id
 property directly.

Another step in the plan to centralize control of React-specific identifers.
---
 src/core/ReactInstanceHandles.js              |   5 +-
 src/core/ReactMount.js                        |   3 +-
 src/core/__tests__/ReactEventEmitter-test.js  | 141 ++++++++++--------
 src/core/__tests__/ReactIdentity-test.js      |   4 +-
 .../__tests__/ReactInstanceHandles-test.js    |  12 +-
 .../ReactMultiChildReconcile-test.js          |   3 +-
 .../__tests__/ReactNativeComponent-test.js    |   3 +-
 src/test/ReactTestUtils.js                    |   2 +-
 8 files changed, 99 insertions(+), 74 deletions(-)

diff --git a/src/core/ReactInstanceHandles.js b/src/core/ReactInstanceHandles.js
index d6a8df0941..50564ac00c 100644
--- a/src/core/ReactInstanceHandles.js
+++ b/src/core/ReactInstanceHandles.js
@@ -285,9 +285,10 @@ var ReactInstanceHandles = {
   findComponentRoot: function(ancestorNode, id) {
     var child = ancestorNode.firstChild;
     while (child) {
-      if (id === child.id) {
+      var childId = ReactID.getID(child);
+      if (id === childId) {
         return child;
-      } else if (isAncestorIDOf(child.id, id)) {
+      } else if (isAncestorIDOf(childId, id)) {
         return ReactInstanceHandles.findComponentRoot(child, id);
       }
       child = child.nextSibling;
diff --git a/src/core/ReactMount.js b/src/core/ReactMount.js
index 6eaf42cfd6..2d9ddfcdb5 100644
--- a/src/core/ReactMount.js
+++ b/src/core/ReactMount.js
@@ -21,6 +21,7 @@
 var ReactEventEmitter = require('ReactEventEmitter');
 var ReactInstanceHandles = require('ReactInstanceHandles');
 var ReactEventTopLevelCallback = require('ReactEventTopLevelCallback');
+var ReactID = require('ReactID');
 
 var $ = require('$');
 
@@ -44,7 +45,7 @@ function getReactRootElementInContainer(container) {
  */
 function getReactRootID(container) {
   var rootElement = getReactRootElementInContainer(container);
-  return rootElement && rootElement.id;
+  return rootElement && ReactID.getID(rootElement);
 }
 
 /**
diff --git a/src/core/__tests__/ReactEventEmitter-test.js b/src/core/__tests__/ReactEventEmitter-test.js
index c2646d3332..79bf8f2390 100644
--- a/src/core/__tests__/ReactEventEmitter-test.js
+++ b/src/core/__tests__/ReactEventEmitter-test.js
@@ -22,6 +22,7 @@ require('mock-modules')
     .dontMock('BrowserScroll')
     .dontMock('CallbackRegistry')
     .dontMock('EventPluginHub')
+    .dontMock('ReactID')
     .dontMock('ReactEventEmitter')
     .dontMock('ReactInstanceHandles')
     .dontMock('EventPluginHub')
@@ -34,6 +35,9 @@ var keyOf = require('keyOf');
 var mocks = require('mocks');
 
 var EventPluginHub;
+var ReactID = require('ReactID');
+var getID = ReactID.getID;
+var setID = ReactID.setID;
 var ReactEventEmitter;
 var ReactEventTopLevelCallback;
 var ReactTestUtils;
@@ -68,15 +72,15 @@ var ON_TOUCH_TAP_KEY = keyOf({onTouchTap: null});
 var CHILD = document.createElement('div');
 var PARENT = document.createElement('div');
 var GRANDPARENT = document.createElement('div');
-CHILD.id = '.reactRoot.[0].[0].[0]';
-PARENT.id = '.reactRoot.[0].[0]';
-GRANDPARENT.id = '.reactRoot.[0]';
+setID(CHILD, '.reactRoot.[0].[0].[0]');
+setID(PARENT, '.reactRoot.[0].[0]');
+setID(GRANDPARENT, '.reactRoot.[0]');
 
 function registerSimpleTestHandler() {
-  ReactEventEmitter.putListener(CHILD.id, ON_CLICK_KEY, LISTENER);
-  var listener = ReactEventEmitter.getListener(CHILD.id, ON_CLICK_KEY);
+  ReactEventEmitter.putListener(getID(CHILD), ON_CLICK_KEY, LISTENER);
+  var listener = ReactEventEmitter.getListener(getID(CHILD), ON_CLICK_KEY);
   expect(listener).toEqual(LISTENER);
-  return ReactEventEmitter.getListener(CHILD.id, ON_CLICK_KEY);
+  return ReactEventEmitter.getListener(getID(CHILD), ON_CLICK_KEY);
 }
 
 
@@ -85,6 +89,9 @@ describe('ReactEventEmitter', function() {
     require('mock-modules').dumpCache();
     EventPluginHub = require('EventPluginHub');
     TapEventPlugin = require('TapEventPlugin');
+    ReactID = require('ReactID');
+    getID = ReactID.getID;
+    setID = ReactID.setID;
     ReactEventEmitter = require('ReactEventEmitter');
     ReactTestUtils = require('ReactTestUtils');
     ReactEventTopLevelCallback = require('ReactEventTopLevelCallback');
@@ -98,20 +105,20 @@ describe('ReactEventEmitter', function() {
 
   it('should store a listener correctly', function() {
     registerSimpleTestHandler();
-    var listener = ReactEventEmitter.getListener(CHILD.id, ON_CLICK_KEY);
+    var listener = ReactEventEmitter.getListener(getID(CHILD), ON_CLICK_KEY);
     expect(listener).toBe(LISTENER);
   });
 
   it('should retrieve a listener correctly', function() {
     registerSimpleTestHandler();
-    var listener = ReactEventEmitter.getListener(CHILD.id, ON_CLICK_KEY);
+    var listener = ReactEventEmitter.getListener(getID(CHILD), ON_CLICK_KEY);
     expect(listener).toEqual(LISTENER);
   });
 
   it('should clear all handlers when asked to', function() {
     registerSimpleTestHandler();
-    ReactEventEmitter.deleteAllListeners(CHILD.id);
-    var listener = ReactEventEmitter.getListener(CHILD.id, ON_CLICK_KEY);
+    ReactEventEmitter.deleteAllListeners(getID(CHILD));
+    var listener = ReactEventEmitter.getListener(getID(CHILD), ON_CLICK_KEY);
     expect(listener).toBe(undefined);
   });
 
@@ -133,89 +140,89 @@ describe('ReactEventEmitter', function() {
 
   it('should bubble simply', function() {
     ReactEventEmitter.putListener(
-      CHILD.id,
+      getID(CHILD),
       ON_CLICK_KEY,
-      recordID.bind(null, CHILD.id)
+      recordID.bind(null, getID(CHILD))
     );
     ReactEventEmitter.putListener(
-      PARENT.id,
+      getID(PARENT),
       ON_CLICK_KEY,
-      recordID.bind(null, PARENT.id)
+      recordID.bind(null, getID(PARENT))
     );
     ReactEventEmitter.putListener(
-      GRANDPARENT.id,
+      getID(GRANDPARENT),
       ON_CLICK_KEY,
-      recordID.bind(null, GRANDPARENT.id)
+      recordID.bind(null, getID(GRANDPARENT))
     );
     ReactTestUtils.Simulate.click(CHILD);
     expect(idCallOrder.length).toBe(3);
-    expect(idCallOrder[0]).toBe(CHILD.id);
-    expect(idCallOrder[1]).toBe(PARENT.id);
-    expect(idCallOrder[2]).toBe(GRANDPARENT.id);
+    expect(idCallOrder[0]).toBe(getID(CHILD));
+    expect(idCallOrder[1]).toBe(getID(PARENT));
+    expect(idCallOrder[2]).toBe(getID(GRANDPARENT));
   });
 
   it('should support stopPropagation()', function() {
     ReactEventEmitter.putListener(
-      CHILD.id,
+      getID(CHILD),
       ON_CLICK_KEY,
-      recordID.bind(null, CHILD.id)
+      recordID.bind(null, getID(CHILD))
     );
     ReactEventEmitter.putListener(
-      PARENT.id,
+      getID(PARENT),
       ON_CLICK_KEY,
-      recordIDAndStopPropagation.bind(null, PARENT.id)
+      recordIDAndStopPropagation.bind(null, getID(PARENT))
     );
     ReactEventEmitter.putListener(
-      GRANDPARENT.id,
+      getID(GRANDPARENT),
       ON_CLICK_KEY,
-      recordID.bind(null, GRANDPARENT.id)
+      recordID.bind(null, getID(GRANDPARENT))
     );
     ReactTestUtils.Simulate.click(CHILD);
     expect(idCallOrder.length).toBe(2);
-    expect(idCallOrder[0]).toBe(CHILD.id);
-    expect(idCallOrder[1]).toBe(PARENT.id);
+    expect(idCallOrder[0]).toBe(getID(CHILD));
+    expect(idCallOrder[1]).toBe(getID(PARENT));
   });
 
   it('should stop after first dispatch if stopPropagation', function() {
     ReactEventEmitter.putListener(
-      CHILD.id,
+      getID(CHILD),
       ON_CLICK_KEY,
-      recordIDAndStopPropagation.bind(null, CHILD.id)
+      recordIDAndStopPropagation.bind(null, getID(CHILD))
     );
     ReactEventEmitter.putListener(
-      PARENT.id,
+      getID(PARENT),
       ON_CLICK_KEY,
-      recordID.bind(null, PARENT.id)
+      recordID.bind(null, getID(PARENT))
     );
     ReactEventEmitter.putListener(
-      GRANDPARENT.id,
+      getID(GRANDPARENT),
       ON_CLICK_KEY,
-      recordID.bind(null, GRANDPARENT.id)
+      recordID.bind(null, getID(GRANDPARENT))
     );
     ReactTestUtils.Simulate.click(CHILD);
     expect(idCallOrder.length).toBe(1);
-    expect(idCallOrder[0]).toBe(CHILD.id);
+    expect(idCallOrder[0]).toBe(getID(CHILD));
   });
 
   it('should stopPropagation if false is returned', function() {
     ReactEventEmitter.putListener(
-      CHILD.id,
+      getID(CHILD),
       ON_CLICK_KEY,
-      recordIDAndReturnFalse.bind(null, CHILD.id)
+      recordIDAndReturnFalse.bind(null, getID(CHILD))
     );
     ReactEventEmitter.putListener(
-      PARENT.id,
+      getID(PARENT),
       ON_CLICK_KEY,
-      recordID.bind(null, PARENT.id)
+      recordID.bind(null, getID(PARENT))
     );
     ReactEventEmitter.putListener(
-      GRANDPARENT.id,
+      getID(GRANDPARENT),
       ON_CLICK_KEY,
-      recordID.bind(null, GRANDPARENT.id)
+      recordID.bind(null, getID(GRANDPARENT))
     );
     ReactTestUtils.Simulate.click(CHILD);
     expect(idCallOrder.length).toBe(1);
-    expect(idCallOrder[0]).toBe(CHILD.id);
+    expect(idCallOrder[0]).toBe(getID(CHILD));
   });
 
   /**
@@ -230,10 +237,14 @@ describe('ReactEventEmitter', function() {
   it('should invoke handlers that were removed while bubbling', function() {
     var handleParentClick = mocks.getMockFunction();
     var handleChildClick = function(event) {
-      ReactEventEmitter.deleteAllListeners(PARENT.id);
+      ReactEventEmitter.deleteAllListeners(getID(PARENT));
     };
-    ReactEventEmitter.putListener(CHILD.id, ON_CLICK_KEY, handleChildClick);
-    ReactEventEmitter.putListener(PARENT.id, ON_CLICK_KEY, handleParentClick);
+    ReactEventEmitter.putListener(getID(CHILD), ON_CLICK_KEY, handleChildClick);
+    ReactEventEmitter.putListener(
+      getID(PARENT),
+      ON_CLICK_KEY,
+      handleParentClick
+    );
     ReactTestUtils.Simulate.click(CHILD);
     expect(handleParentClick.mock.calls.length).toBe(1);
   });
@@ -241,18 +252,22 @@ describe('ReactEventEmitter', function() {
   it('should not invoke newly inserted handlers while bubbling', function() {
     var handleParentClick = mocks.getMockFunction();
     var handleChildClick = function(event) {
-      ReactEventEmitter.putListener(PARENT.id, ON_CLICK_KEY, handleParentClick);
+      ReactEventEmitter.putListener(
+        getID(PARENT),
+        ON_CLICK_KEY,
+        handleParentClick
+      );
     };
-    ReactEventEmitter.putListener(CHILD.id, ON_CLICK_KEY, handleChildClick);
+    ReactEventEmitter.putListener(getID(CHILD), ON_CLICK_KEY, handleChildClick);
     ReactTestUtils.Simulate.click(CHILD);
     expect(handleParentClick.mock.calls.length).toBe(0);
   });
 
   it('should infer onTouchTap from a touchStart/End', function() {
     ReactEventEmitter.putListener(
-      CHILD.id,
+      getID(CHILD),
       ON_TOUCH_TAP_KEY,
-      recordID.bind(null, CHILD.id)
+      recordID.bind(null, getID(CHILD))
     );
     ReactTestUtils.Simulate.touchStart(
       CHILD,
@@ -263,14 +278,14 @@ describe('ReactEventEmitter', function() {
       ReactTestUtils.nativeTouchData(0, 0)
     );
     expect(idCallOrder.length).toBe(1);
-    expect(idCallOrder[0]).toBe(CHILD.id);
+    expect(idCallOrder[0]).toBe(getID(CHILD));
   });
 
   it('should infer onTouchTap from when dragging below threshold', function() {
     ReactEventEmitter.putListener(
-      CHILD.id,
+      getID(CHILD),
       ON_TOUCH_TAP_KEY,
-      recordID.bind(null, CHILD.id)
+      recordID.bind(null, getID(CHILD))
     );
     ReactTestUtils.Simulate.touchStart(
       CHILD,
@@ -281,14 +296,14 @@ describe('ReactEventEmitter', function() {
       ReactTestUtils.nativeTouchData(0, tapMoveThreshold - 1)
     );
     expect(idCallOrder.length).toBe(1);
-    expect(idCallOrder[0]).toBe(CHILD.id);
+    expect(idCallOrder[0]).toBe(getID(CHILD));
   });
 
   it('should not onTouchTap from when dragging beyond threshold', function() {
     ReactEventEmitter.putListener(
-      CHILD.id,
+      getID(CHILD),
       ON_TOUCH_TAP_KEY,
-      recordID.bind(null, CHILD.id)
+      recordID.bind(null, getID(CHILD))
     );
     ReactTestUtils.Simulate.touchStart(
       CHILD,
@@ -304,19 +319,19 @@ describe('ReactEventEmitter', function() {
 
   it('should bubble onTouchTap', function() {
     ReactEventEmitter.putListener(
-      CHILD.id,
+      getID(CHILD),
       ON_TOUCH_TAP_KEY,
-      recordID.bind(null, CHILD.id)
+      recordID.bind(null, getID(CHILD))
     );
     ReactEventEmitter.putListener(
-      PARENT.id,
+      getID(PARENT),
       ON_TOUCH_TAP_KEY,
-      recordID.bind(null, PARENT.id)
+      recordID.bind(null, getID(PARENT))
     );
     ReactEventEmitter.putListener(
-      GRANDPARENT.id,
+      getID(GRANDPARENT),
       ON_TOUCH_TAP_KEY,
-      recordID.bind(null, GRANDPARENT.id)
+      recordID.bind(null, getID(GRANDPARENT))
     );
     ReactTestUtils.Simulate.touchStart(
       CHILD,
@@ -327,9 +342,9 @@ describe('ReactEventEmitter', function() {
       ReactTestUtils.nativeTouchData(0, 0)
     );
     expect(idCallOrder.length).toBe(3);
-    expect(idCallOrder[0]).toBe(CHILD.id);
-    expect(idCallOrder[1]).toBe(PARENT.id);
-    expect(idCallOrder[2]).toBe(GRANDPARENT.id);
+    expect(idCallOrder[0]).toBe(getID(CHILD));
+    expect(idCallOrder[1]).toBe(getID(PARENT));
+    expect(idCallOrder[2]).toBe(getID(GRANDPARENT));
   });
 
 });
diff --git a/src/core/__tests__/ReactIdentity-test.js b/src/core/__tests__/ReactIdentity-test.js
index f92a4c3e0b..9edf0f73ef 100644
--- a/src/core/__tests__/ReactIdentity-test.js
+++ b/src/core/__tests__/ReactIdentity-test.js
@@ -22,6 +22,7 @@
 var React;
 var ReactTestUtils;
 var reactComponentExpect;
+var ReactID;
 
 describe('ReactIdentity', function() {
 
@@ -30,11 +31,12 @@ describe('ReactIdentity', function() {
     React = require('React');
     ReactTestUtils = require('ReactTestUtils');
     reactComponentExpect = require('reactComponentExpect');
+    ReactID = require('ReactID');
   });
 
   var idExp = /^\.reactRoot\[\d+\](.*)$/;
   function checkId(child, expectedId) {
-    var actual = idExp.exec(child.id);
+    var actual = idExp.exec(ReactID.getID(child));
     var expected = idExp.exec(expectedId);
     expect(actual).toBeTruthy();
     expect(expected).toBeTruthy();
diff --git a/src/core/__tests__/ReactInstanceHandles-test.js b/src/core/__tests__/ReactInstanceHandles-test.js
index 95e03d8250..34531223fa 100644
--- a/src/core/__tests__/ReactInstanceHandles-test.js
+++ b/src/core/__tests__/ReactInstanceHandles-test.js
@@ -21,6 +21,7 @@
 
 var React = require('React');
 var ReactTestUtils = require('ReactTestUtils');
+var ReactID = require('ReactID');
 
 /**
  * Ensure that all callbacks are invoked, passing this unique argument.
@@ -90,12 +91,15 @@ describe('ReactInstanceHandles', function() {
       parentNode.appendChild(childNodeA);
       parentNode.appendChild(childNodeB);
 
-      parentNode.id = '.react[0]';
-      childNodeA.id = '.react[0].0';
-      childNodeB.id = '.react[0].0:1';
+      ReactID.setID(parentNode, '.react[0]');
+      ReactID.setID(childNodeA, '.react[0].0');
+      ReactID.setID(childNodeB, '.react[0].0:1');
 
       expect(
-        ReactInstanceHandles.findComponentRoot(parentNode, childNodeB.id)
+        ReactInstanceHandles.findComponentRoot(
+          parentNode,
+          ReactID.getID(childNodeB)
+        )
       ).toBe(childNodeB);
     });
   });
diff --git a/src/core/__tests__/ReactMultiChildReconcile-test.js b/src/core/__tests__/ReactMultiChildReconcile-test.js
index 597ca8f182..81b680c35b 100644
--- a/src/core/__tests__/ReactMultiChildReconcile-test.js
+++ b/src/core/__tests__/ReactMultiChildReconcile-test.js
@@ -23,6 +23,7 @@ require('mock-modules');
 
 var React = require('React');
 var ReactTestUtils = require('ReactTestUtils');
+var ReactID = require('ReactID');
 
 var objMapKeyVal = require('objMapKeyVal');
 
@@ -191,7 +192,7 @@ function verifyDomOrderingAccurate(parentInstance, statusDisplays) {
   var i;
   var orderedDomIds = [];
   for (i=0; i < statusDisplayNodes.length; i++) {
-    orderedDomIds.push(statusDisplayNodes[i].id);
+    orderedDomIds.push(ReactID.getID(statusDisplayNodes[i]));
   }
 
   var orderedLogicalIds = [];
diff --git a/src/core/__tests__/ReactNativeComponent-test.js b/src/core/__tests__/ReactNativeComponent-test.js
index 55e5f13ec6..2611f1d442 100644
--- a/src/core/__tests__/ReactNativeComponent-test.js
+++ b/src/core/__tests__/ReactNativeComponent-test.js
@@ -328,6 +328,7 @@ describe('ReactNativeComponent', function() {
     it("should clean up listeners", function() {
       var React = require('React');
       var ReactEventEmitter = require('ReactEventEmitter');
+      var ReactID = require('ReactID');
 
       var container = document.createElement('div');
       document.documentElement.appendChild(container);
@@ -337,7 +338,7 @@ describe('ReactNativeComponent', function() {
       React.renderComponent(instance, container);
 
       var rootNode = instance.getDOMNode();
-      var rootNodeID = rootNode.id;
+      var rootNodeID = ReactID.getID(rootNode);
       expect(
         ReactEventEmitter.getListener(rootNodeID, 'onClick')
       ).toBe(callback);
diff --git a/src/test/ReactTestUtils.js b/src/test/ReactTestUtils.js
index 56c43e0bce..b8784183d6 100644
--- a/src/test/ReactTestUtils.js
+++ b/src/test/ReactTestUtils.js
@@ -225,7 +225,7 @@ var ReactTestUtils = {
     var node = ReactID.getNode(reactRootID);
     fakeNativeEvent.target = node;
     /* jsdom is returning nodes without id's - fixing that issue here. */
-    node.id = reactRootID;
+    ReactID.setID(node, reactRootID);
     virtualHandler(fakeNativeEvent);
   },
 

From 7053f59ad11c3483da1c163f80c4b2de7f901f77 Mon Sep 17 00:00:00 2001
From: petehunt <floydophone@gmail.com>
Date: Sun, 16 Jun 2013 19:35:39 -0700
Subject: [PATCH 45/94] Remove second argument to invariant()

---
 vendor/constants.js | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/vendor/constants.js b/vendor/constants.js
index b0530b4d69..339398c2a8 100644
--- a/vendor/constants.js
+++ b/vendor/constants.js
@@ -34,6 +34,15 @@ var ConstantVisitor = recast.Visitor.extend({
     }
   },
 
+  visitCallExpression: function(call) {
+    if (!this.constants.__DEV__) {
+      if (call.callee.type === 'Identifier' && call.callee.name === 'invariant') {
+        call.arguments.length = 1;
+      }
+    }
+    this.genericVisit(call);
+  },
+
   visitIfStatement: function(stmt) {
     // Replaces all identifiers in this.constants with literal values.
     this.genericVisit(stmt);

From c9ecbaccb365ba39bd8839f61ae245cdc295317b Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 24 Jun 2013 16:09:09 -0700
Subject: [PATCH 46/94] Use React.autoBind by default.

Per our discussion - this is the general approach we'd like to take for
the public facing API.

    var MyComponent = React.createClass({
      render: function() {
        return <div onClick={this.myCallback} />;
      },
      myCallback: function() {
      }
    });
---
 src/core/ReactCompositeComponent.js           | 217 +++++++++---------
 src/core/ReactDoNotBindDeprecated.js          |  48 ++++
 src/core/ReactID.js                           |   2 +-
 src/core/__tests__/ReactBind-test.js          |  19 +-
 .../__tests__/ReactComponentLifeCycle-test.js |  76 +-----
 .../__tests__/ReactCompositeComponent-test.js |  50 ++--
 6 files changed, 217 insertions(+), 195 deletions(-)
 create mode 100644 src/core/ReactDoNotBindDeprecated.js

diff --git a/src/core/ReactCompositeComponent.js b/src/core/ReactCompositeComponent.js
index 6e79b9ca97..6d4a6ee0d9 100644
--- a/src/core/ReactCompositeComponent.js
+++ b/src/core/ReactCompositeComponent.js
@@ -28,6 +28,17 @@ var keyMirror = require('keyMirror');
 var merge = require('merge');
 var mixInto = require('mixInto');
 
+var invokedBeforeMount = function() {
+  invariant(
+    false,
+    'You have invoked a method that is automatically bound, before the ' +
+    'instance has been mounted. There is nothing conceptually wrong with ' +
+    'this, but since this method will be replaced with a new version once ' +
+    'the component is mounted - you should be aware of the fact that this ' +
+    'method will soon be replaced.'
+  );
+};
+
 /**
  * Policies that describe methods in `ReactCompositeComponentInterface`.
  */
@@ -283,6 +294,47 @@ var RESERVED_SPEC_KEYS = {
   }
 };
 
+function validateMethodOverride(proto, name) {
+  var specPolicy = ReactCompositeComponentInterface[name];
+
+  // Disallow overriding of base class methods unless explicitly allowed.
+  if (ReactCompositeComponentMixin.hasOwnProperty(name)) {
+    invariant(
+      specPolicy === SpecPolicy.OVERRIDE_BASE,
+      'ReactCompositeComponentInterface: You are attempting to override ' +
+      '`%s` from your class specification. Ensure that your method names ' +
+      'do not overlap with React methods.',
+      name
+    );
+  }
+
+  // Disallow defining methods more than once unless explicitly allowed.
+  if (proto.hasOwnProperty(name)) {
+    invariant(
+      specPolicy === SpecPolicy.DEFINE_MANY,
+      'ReactCompositeComponentInterface: You are attempting to define ' +
+      '`%s` on your component more than once. This conflict may be due ' +
+      'to a mixin.',
+      name
+    );
+  }
+}
+
+
+function validateLifeCycleOnReplaceState(instance) {
+  var compositeLifeCycleState = instance._compositeLifeCycleState;
+  invariant(
+    instance.isMounted(),
+    'replaceState(...): Can only update a mounted component.'
+  );
+  invariant(
+    compositeLifeCycleState !== CompositeLifeCycle.RECEIVING_STATE &&
+    compositeLifeCycleState !== CompositeLifeCycle.UNMOUNTING,
+    'replaceState(...): Cannot update while unmounting component or during ' +
+    'an existing state transition (such as within `render`).'
+  );
+}
+
 /**
  * Custom version of `mixInto` which handles policy validation and reserved
  * specification keys when building `ReactCompositeComponent` classses.
@@ -290,58 +342,44 @@ var RESERVED_SPEC_KEYS = {
 function mixSpecIntoComponent(Constructor, spec) {
   var proto = Constructor.prototype;
   for (var name in spec) {
-    if (!spec.hasOwnProperty(name)) {
+    var property = spec[name];
+    if (!spec.hasOwnProperty(name) || !property) {
       continue;
     }
-    var property = spec[name];
-    var specPolicy = ReactCompositeComponentInterface[name];
-
-    // Disallow overriding of base class methods unless explicitly allowed.
-    if (ReactCompositeComponentMixin.hasOwnProperty(name)) {
-      invariant(
-        specPolicy === SpecPolicy.OVERRIDE_BASE,
-        'ReactCompositeComponentInterface: You are attempting to override ' +
-        '`%s` from your class specification. Ensure that your method names ' +
-        'do not overlap with React methods.',
-        name
-      );
-    }
-
-    // Disallow using `React.autoBind` on internal methods.
-    if (specPolicy != null) {
-      invariant(
-        !property || !property.__reactAutoBind,
-        'ReactCompositeComponentInterface: You are attempting to use ' +
-        '`React.autoBind` on `%s`, a method that is internal to React.' +
-        'Internal methods are called with the component as the context.',
-        name
-      );
-    }
-
-    // Disallow defining methods more than once unless explicitly allowed.
-    if (proto.hasOwnProperty(name)) {
-      invariant(
-        specPolicy === SpecPolicy.DEFINE_MANY,
-        'ReactCompositeComponentInterface: You are attempting to define ' +
-        '`%s` on your component more than once. This conflict may be due ' +
-        'to a mixin.',
-        name
-      );
-    }
+    validateMethodOverride(proto, name);
 
     if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {
       RESERVED_SPEC_KEYS[name](Constructor, property);
-    } else if (property && property.__reactAutoBind) {
-      if (!proto.__reactAutoBindMap) {
-        proto.__reactAutoBindMap = {};
-      }
-      proto.__reactAutoBindMap[name] = property.__reactAutoBind;
-    } else if (proto.hasOwnProperty(name)) {
-      // For methods which are defined more than once, call the existing methods
-      // before calling the new property.
-      proto[name] = createChainedFunction(proto[name], property);
     } else {
-      proto[name] = property;
+      // Setup methods on prototype:
+      // The following member methods should not be automatically bound:
+      // 1. Expected ReactCompositeComponent methods (in the "interface").
+      // 2. Overridden methods (that were mixed in).
+      var isCompositeComponentMethod = name in ReactCompositeComponentInterface;
+      var isInherited = name in proto;
+      var markedDontBind = property.__reactDontBind;
+      var isFunction = typeof property === 'function';
+      var shouldAutoBind =
+        isFunction &&
+        !isCompositeComponentMethod &&
+        !isInherited &&
+        !markedDontBind;
+
+      if (shouldAutoBind) {
+        if (!proto.__reactAutoBindMap) {
+          proto.__reactAutoBindMap = {};
+        }
+        proto.__reactAutoBindMap[name] = property;
+        proto[name] = invokedBeforeMount;
+      } else {
+        if (isInherited) {
+          // For methods which are defined more than once, call the existing
+          // methods before calling the new property.
+          proto[name] = createChainedFunction(proto[name], property);
+        } else {
+          proto[name] = property;
+        }
+      }
     }
   }
 }
@@ -370,7 +408,26 @@ function createChainedFunction(one, two) {
  * `this._compositeLifeCycleState` (which can be null).
  *
  * This is different from the life cycle state maintained by `ReactComponent` in
- * `this._lifeCycleState`.
+ * `this._lifeCycleState`. The following diagram shows how the states overlap in
+ * time. There are times when the CompositeLifeCycle is null - at those times it
+ * is only meaningful to look at ComponentLifeCycle alone.
+ *
+ * Top Row: ReactComponent.ComponentLifeCycle
+ * Low Row: ReactComponent.CompositeLifeCycle
+ *
+ * +-------+------------------------------------------------------+--------+
+ * |  UN   |                    MOUNTED                           |   UN   |
+ * |MOUNTED|                                                      | MOUNTED|
+ * +-------+------------------------------------------------------+--------+
+ * |       ^--------+   +------+   +------+   +------+   +--------^        |
+ * |       |        |   |      |   |      |   |      |   |        |        |
+ * |    0--|MOUNTING|-0-|RECEIV|-0-|RECEIV|-0-|RECEIV|-0-|   UN   |--->0   |
+ * |       |        |   |PROPS |   | PROPS|   | STATE|   |MOUNTING|        |
+ * |       |        |   |      |   |      |   |      |   |        |        |
+ * |       |        |   |      |   |      |   |      |   |        |        |
+ * |       +--------+   +------+   +------+   +------+   +--------+        |
+ * |       |                                                      |        |
+ * +-------+------------------------------------------------------+--------+
  */
 var CompositeLifeCycle = keyMirror({
   /**
@@ -429,11 +486,7 @@ var ReactCompositeComponentMixin = {
    */
   mountComponent: function(rootID, transaction) {
     ReactComponent.Mixin.mountComponent.call(this, rootID, transaction);
-
-    // Unset `this._lifeCycleState` until after this method is finished.
-    this._lifeCycleState = ReactComponent.LifeCycle.UNMOUNTED;
     this._compositeLifeCycleState = CompositeLifeCycle.MOUNTING;
-
     this._processProps(this.props);
 
     if (this.__reactAutoBindMap) {
@@ -459,15 +512,11 @@ var ReactCompositeComponentMixin = {
 
     // Done with mounting, `setState` will now trigger UI changes.
     this._compositeLifeCycleState = null;
-    this._lifeCycleState = ReactComponent.LifeCycle.MOUNTED;
-
-    var html = this._renderedComponent.mountComponent(rootID, transaction);
-
+    var markup = this._renderedComponent.mountComponent(rootID, transaction);
     if (this.componentDidMount) {
       transaction.getReactOnDOMReady().enqueue(this, this.componentDidMount);
     }
-
-    return html;
+    return markup;
   },
 
   /**
@@ -551,18 +600,7 @@ var ReactCompositeComponentMixin = {
    */
   replaceState: function(completeState) {
     var compositeLifeCycleState = this._compositeLifeCycleState;
-    invariant(
-      this.isMounted() ||
-      compositeLifeCycleState === CompositeLifeCycle.MOUNTING,
-      'replaceState(...): Can only update a mounted (or mounting) component.'
-    );
-    invariant(
-      compositeLifeCycleState !== CompositeLifeCycle.RECEIVING_STATE &&
-      compositeLifeCycleState !== CompositeLifeCycle.UNMOUNTING,
-      'replaceState(...): Cannot update while unmounting component or during ' +
-      'an existing state transition (such as within `render`).'
-    );
-
+    validateLifeCycleOnReplaceState.call(null, this);
     this._pendingState = completeState;
 
     // Do not trigger a state transition if we are in the middle of mounting or
@@ -583,7 +621,6 @@ var ReactCompositeComponentMixin = {
         transaction
       );
       ReactComponent.ReactReconcileTransaction.release(transaction);
-
       this._compositeLifeCycleState = null;
     }
   },
@@ -777,25 +814,12 @@ var ReactCompositeComponentMixin = {
    */
   _bindAutoBindMethod: function(method) {
     var component = this;
-    var hasWarned = false;
     function autoBound(a, b, c, d, e, tooMany) {
       invariant(
         typeof tooMany === 'undefined',
         'React.autoBind(...): Methods can only take a maximum of 5 arguments.'
       );
-      if (component._lifeCycleState === ReactComponent.LifeCycle.MOUNTED) {
-        return method.call(component, a, b, c, d, e);
-      } else if (!hasWarned) {
-        hasWarned = true;
-        if (__DEV__) {
-          console.warn(
-            'React.autoBind(...): Attempted to invoke an auto-bound method ' +
-            'on an unmounted instance of `%s`. You either have a memory leak ' +
-            'or an event handler that is being run after unmounting.',
-            component.constructor.displayName || 'ReactCompositeComponent'
-          );
-        }
-      }
+      return method.call(component, a, b, c, d, e);
     }
     return autoBound;
   }
@@ -850,33 +874,16 @@ var ReactCompositeComponent = {
   },
 
   /**
-   * Marks the provided method to be automatically bound to the component.
-   * This means the method's context will always be the component.
-   *
-   *   React.createClass({
-   *     handleClick: React.autoBind(function() {
-   *       this.setState({jumping: true});
-   *     }),
-   *     render: function() {
-   *       return <a onClick={this.handleClick}>Jump</a>;
-   *     }
-   *   });
+   * TODO: Delete this when all callers have been updated to rely on this
+   * behavior being the default.
    *
+   * Backwards compatible stub for what is now the default behavior.
    * @param {function} method Method to be bound.
    * @public
    */
   autoBind: function(method) {
-    function unbound() {
-      invariant(
-        false,
-        'React.autoBind(...): Attempted to invoke an auto-bound method that ' +
-        'was not correctly defined on the class specification.'
-      );
-    }
-    unbound.__reactAutoBind = method;
-    return unbound;
+    return method;
   }
-
 };
 
 module.exports = ReactCompositeComponent;
diff --git a/src/core/ReactDoNotBindDeprecated.js b/src/core/ReactDoNotBindDeprecated.js
new file mode 100644
index 0000000000..11b6c00166
--- /dev/null
+++ b/src/core/ReactDoNotBindDeprecated.js
@@ -0,0 +1,48 @@
+/**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @providesModule ReactDoNotBindDeprecated
+ */
+
+var ReactDoNotBindDeprecated = {
+  /**
+   * Marks the method for not being automatically bound on component mounting. A
+   * couple of reasons you might want to use this:
+   *
+   * - Automatically supporting the previous behavior in components that were
+   *   built with previous versions of React.
+   * - Tuning performance, by avoiding binding on initial render for methods
+   *   that are always invoked while being preceded by `this.`. Such binds are
+   *   unnecessary.
+   *
+   *   React.createClass({
+   *     handleClick: ReactDoNotBindDeprecated.doNotBind(function() {
+   *       alert(this.setState); // undefined!
+   *     }),
+   *     render: function() {
+   *       return <a onClick={this.handleClick}>Jump</a>;
+   *     }
+   *   });
+   *
+   * @param {function} method Method to avoid automatically binding.
+   * @public
+   */
+  doNotBind: function(method) {
+    method.__reactDontBind = true;   // Mutating
+    return method;
+  }
+};
+
+module.exports = ReactDoNotBindDeprecated;
diff --git a/src/core/ReactID.js b/src/core/ReactID.js
index 313ccebefe..edc5a10e0e 100644
--- a/src/core/ReactID.js
+++ b/src/core/ReactID.js
@@ -30,7 +30,7 @@ var nodeCache = {};
  * other objects so just return '' if we're given something other than a
  * DOM node (such as window).
  *
- * @param {DOMElement|DOMWindow|DOMDocument} node DOM node.
+ * @param {?DOMElement|DOMWindow|DOMDocument|DOMTextNode} node DOM node.
  * @returns {string} ID of the supplied `domNode`.
  */
 function getID(node) {
diff --git a/src/core/__tests__/ReactBind-test.js b/src/core/__tests__/ReactBind-test.js
index 2fa5f77c59..4d31f38ab0 100644
--- a/src/core/__tests__/ReactBind-test.js
+++ b/src/core/__tests__/ReactBind-test.js
@@ -21,9 +21,11 @@
 
 var mocks = require('mocks');
 var React = require('React');
+var ReactDoNotBindDeprecated = require('ReactDoNotBindDeprecated');
 var ReactTestUtils = require('ReactTestUtils');
 var reactComponentExpect = require('reactComponentExpect');
 
+// TODO: Test render and all stock methods.
 describe('React.autoBind', function() {
 
   it('Holds reference to instance', function() {
@@ -31,16 +33,20 @@ describe('React.autoBind', function() {
     var mouseDidEnter = mocks.getMockFunction();
     var mouseDidLeave = mocks.getMockFunction();
     var mouseDidClick = mocks.getMockFunction();
-    var didBadIdea = mocks.getMockFunction();
 
     var TestBindComponent = React.createClass({
-      onMouseEnter: mouseDidEnter,
-      onMouseLeave: mouseDidLeave,
+      getInitialState: function() {
+        return {something: 'hi'};
+      },
+      onMouseEnter: ReactDoNotBindDeprecated.doNotBind(mouseDidEnter),
+      onMouseLeave: ReactDoNotBindDeprecated.doNotBind(mouseDidLeave),
       onClick: React.autoBind(mouseDidClick),
 
-      // autoBind needs to be on the top-level spec.
+      // auto binding only occurs on top level functions in class defs.
       badIdeas: {
-        badBind: React.autoBind(didBadIdea)
+        badBind: function() {
+          this.state.something;
+        }
       },
 
       render: function() {
@@ -48,7 +54,8 @@ describe('React.autoBind', function() {
           <div
             onMouseEnter={this.onMouseEnter.bind(this)}
             onMouseLeave={this.onMouseLeave}
-            onClick={this.onClick} />
+            onClick={this.onClick}
+          />
         );
       }
     });
diff --git a/src/core/__tests__/ReactComponentLifeCycle-test.js b/src/core/__tests__/ReactComponentLifeCycle-test.js
index 4f66eb10e2..a3c18be304 100644
--- a/src/core/__tests__/ReactComponentLifeCycle-test.js
+++ b/src/core/__tests__/ReactComponentLifeCycle-test.js
@@ -286,6 +286,8 @@ describe('ReactComponentLifeCycle', function() {
         if (isInitialRender) {
           this._testJournal.stateInInitialRender = clone(this.state);
           this._testJournal.lifeCycleInInitialRender = this._lifeCycleState;
+          this._testJournal.compositeLifeCycleInInitialRender =
+            this._compositeLifeCycleState;
         } else {
           this._testJournal.stateInLaterRender = clone(this.state);
           this._testJournal.lifeCycleInLaterRender = this._lifeCycleState;
@@ -319,7 +321,7 @@ describe('ReactComponentLifeCycle', function() {
       GET_INIT_STATE_RETURN_VAL
     );
     expect(instance._testJournal.lifeCycleAtStartOfGetInitialState)
-      .toBe(ComponentLifeCycle.UNMOUNTED);
+      .toBe(ComponentLifeCycle.MOUNTED);
     expect(instance._testJournal.compositeLifeCycleAtStartOfGetInitialState)
       .toBe(CompositeComponentLifeCycle.MOUNTING);
 
@@ -328,7 +330,7 @@ describe('ReactComponentLifeCycle', function() {
       instance._testJournal.returnedFromGetInitialState
     );
     expect(instance._testJournal.lifeCycleAtStartOfWillMount)
-      .toBe(ComponentLifeCycle.UNMOUNTED);
+      .toBe(ComponentLifeCycle.MOUNTED);
     expect(instance._testJournal.compositeLifeCycleAtStartOfWillMount)
       .toBe(CompositeComponentLifeCycle.MOUNTING);
 
@@ -343,7 +345,10 @@ describe('ReactComponentLifeCycle', function() {
     expect(instance._testJournal.stateInInitialRender)
       .toEqual(INIT_RENDER_STATE);
     expect(instance._testJournal.lifeCycleInInitialRender).toBe(
-      ComponentLifeCycle.UNMOUNTED
+      ComponentLifeCycle.MOUNTED
+    );
+    expect(instance._testJournal.compositeLifeCycleInInitialRender).toBe(
+      CompositeComponentLifeCycle.MOUNTING
     );
 
     expect(instance._lifeCycleState).toBe(ComponentLifeCycle.MOUNTED);
@@ -429,70 +434,5 @@ describe('ReactComponentLifeCycle', function() {
     expect(instance.state.stateField).toBe('goodbye');
   });
 
-  it('should call nested lifecycle methods in the right order', function() {
-    var log;
-    var logger = function(msg) {
-      return function() {
-        // return true for shouldComponentUpdate
-        log.push(msg);
-        return true;
-      };
-    };
-    var Outer = React.createClass({
-      render: function() {
-        return <div><Inner x={this.props.x} /></div>;
-      },
-      componentWillMount: logger('outer componentWillMount'),
-      componentDidMount: logger('outer componentDidMount'),
-      componentWillReceiveProps: logger('outer componentWillReceiveProps'),
-      shouldComponentUpdate: logger('outer shouldComponentUpdate'),
-      componentWillUpdate: logger('outer componentWillUpdate'),
-      componentDidUpdate: logger('outer componentDidUpdate'),
-      componentWillUnmount: logger('outer componentWillUnmount')
-    });
-    var Inner = React.createClass({
-      render: function() {
-        return <span>{this.props.x}</span>;
-      },
-      componentWillMount: logger('inner componentWillMount'),
-      componentDidMount: logger('inner componentDidMount'),
-      componentWillReceiveProps: logger('inner componentWillReceiveProps'),
-      shouldComponentUpdate: logger('inner shouldComponentUpdate'),
-      componentWillUpdate: logger('inner componentWillUpdate'),
-      componentDidUpdate: logger('inner componentDidUpdate'),
-      componentWillUnmount: logger('inner componentWillUnmount')
-    });
-    var instance;
-
-    log = [];
-    instance = ReactTestUtils.renderIntoDocument(<Outer x={17} />);
-    expect(log).toEqual([
-      'outer componentWillMount',
-      'inner componentWillMount',
-      'inner componentDidMount',
-      'outer componentDidMount'
-    ]);
-
-    log = [];
-    instance.setProps({x: 42});
-    expect(log).toEqual([
-      'outer componentWillReceiveProps',
-      'outer shouldComponentUpdate',
-      'outer componentWillUpdate',
-      'inner componentWillReceiveProps',
-      'inner shouldComponentUpdate',
-      'inner componentWillUpdate',
-      'inner componentDidUpdate',
-      'outer componentDidUpdate'
-    ]);
-
-    log = [];
-    instance.unmountComponent();
-    expect(log).toEqual([
-      'outer componentWillUnmount',
-      'inner componentWillUnmount'
-    ]);
-  });
-
 });
 
diff --git a/src/core/__tests__/ReactCompositeComponent-test.js b/src/core/__tests__/ReactCompositeComponent-test.js
index 5a6e9602bf..d6623e9daa 100644
--- a/src/core/__tests__/ReactCompositeComponent-test.js
+++ b/src/core/__tests__/ReactCompositeComponent-test.js
@@ -27,6 +27,7 @@ var ReactCurrentOwner;
 var ReactProps;
 var ReactTestUtils;
 var ReactID;
+var ReactDoNotBindDeprecated;
 
 var cx;
 var reactComponentExpect;
@@ -38,6 +39,7 @@ describe('ReactCompositeComponent', function() {
     reactComponentExpect = require('reactComponentExpect');
     React = require('React');
     ReactCurrentOwner = require('ReactCurrentOwner');
+    ReactDoNotBindDeprecated = require('ReactDoNotBindDeprecated');
     ReactProps = require('ReactProps');
     ReactTestUtils = require('ReactTestUtils');
     ReactID = require('ReactID');
@@ -52,7 +54,7 @@ describe('ReactCompositeComponent', function() {
       },
 
       render: function() {
-        var toggleActivatedState = this._toggleActivatedState.bind(this);
+        var toggleActivatedState = this._toggleActivatedState;
         return !this.state.activated ?
           <a ref="x" onClick={toggleActivatedState} /> :
           <b ref="x" onClick={toggleActivatedState} />;
@@ -64,9 +66,9 @@ describe('ReactCompositeComponent', function() {
         return {activated: false};
       },
 
-      _toggleActivatedState: React.autoBind(function() {
+      _toggleActivatedState:function() {
         this.setState({activated: !this.state.activated});
-      }),
+      },
 
       render: function() {
         return !this.state.activated ?
@@ -167,15 +169,18 @@ describe('ReactCompositeComponent', function() {
   });
 
   it('should auto bind methods and values correctly', function() {
-    var RETURN_VALUE_AFTER_MOUNT = 'returnValue';
     var ComponentClass = React.createClass({
       getInitialState: function() {
-        return {
-          valueToReturn: RETURN_VALUE_AFTER_MOUNT
-        };
+        return {valueToReturn: 'hi'};
       },
-      methodBoundOnMount: React.autoBind(function() {
-        return this.state.valueToReturn;
+      methodToBeExplicitlyBound: function() {
+        return this;
+      },
+      methodAutoBound: function() {
+        return this;
+      },
+      methodExplicitlyNotBound: ReactDoNotBindDeprecated.doNotBind(function() {
+        return this;
       }),
       render: function() {
         return <div> </div>;
@@ -184,18 +189,33 @@ describe('ReactCompositeComponent', function() {
     var instance = <ComponentClass />;
 
     // Autobound methods will throw before mounting.
+    // TODO: We should actually allow component instance methods to be invoked
+    // before mounting for read-only operations. We would then update this test.
     expect(function() {
-      instance.methodBoundOnMount();
+      instance.methodToBeExplicitlyBound.bind(instance)();
     }).toThrow();
+    expect(function() {
+      instance.methodAutoBound();
+    }).toThrow();
+    expect(function() {
+      instance.methodExplicitlyNotBound();
+    }).not.toThrow();
 
     // Next, prove that once mounted, the scope is bound correctly to the actual
     // component.
     ReactTestUtils.renderIntoDocument(instance);
-    var retValAfterMount = instance.methodBoundOnMount();
-    expect(retValAfterMount).toBe(RETURN_VALUE_AFTER_MOUNT);
-    var retValAfterMountWithCrazyScope =
-      instance.methodBoundOnMount.call({thisIsACrazyScope:null});
-    expect(retValAfterMountWithCrazyScope).toBe(RETURN_VALUE_AFTER_MOUNT);
+    var explicitlyBound = instance.methodToBeExplicitlyBound.bind(instance);
+    var autoBound = instance.methodAutoBound;
+    var explicitlyNotBound = instance.methodExplicitlyNotBound;
+
+    expect(explicitlyBound.call(null)).toBe(instance);
+    expect(autoBound.call(null)).toBe(instance);
+    expect(explicitlyNotBound.call(null)).toBe(null);
+
+    expect(explicitlyBound.call(instance)).toBe(instance);
+    expect(autoBound.call(instance)).toBe(instance);
+    expect(explicitlyNotBound.call(instance)).toBe(instance);
+
   });
 
   it('should normalize props with default values', function() {

From 3266818b42fbb035ea8d9b48c8a97da5f3e9d756 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 24 Jun 2013 16:09:18 -0700
Subject: [PATCH 47/94] fix bad caching in ReactID.getID

---
 src/core/ReactID.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/ReactID.js b/src/core/ReactID.js
index edc5a10e0e..9bfba32bfa 100644
--- a/src/core/ReactID.js
+++ b/src/core/ReactID.js
@@ -65,7 +65,7 @@ function setID(node, id) {
  * @internal
  */
 function getNode(id) {
-  if (!nodeCache.hasOwnProperty(id)) {
+  if (!nodeCache[id]) {
     nodeCache[id] =
       document.getElementById(id) || // TODO Quit using getElementById.
       ReactMount.findReactRenderedDOMNodeSlow(id);

From a61f4df0b9b23250a5a59285aad82cf7d82a19b8 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 24 Jun 2013 16:09:26 -0700
Subject: [PATCH 48/94] Fix a bunch of problems with implicit autobinding

---
 src/core/ReactCompositeComponent.js           | 41 +++++++++++--------
 .../__tests__/ReactCompositeComponent-test.js |  9 ----
 2 files changed, 23 insertions(+), 27 deletions(-)

diff --git a/src/core/ReactCompositeComponent.js b/src/core/ReactCompositeComponent.js
index 6d4a6ee0d9..e97b5439fc 100644
--- a/src/core/ReactCompositeComponent.js
+++ b/src/core/ReactCompositeComponent.js
@@ -28,16 +28,18 @@ var keyMirror = require('keyMirror');
 var merge = require('merge');
 var mixInto = require('mixInto');
 
-var invokedBeforeMount = function() {
-  invariant(
-    false,
-    'You have invoked a method that is automatically bound, before the ' +
-    'instance has been mounted. There is nothing conceptually wrong with ' +
-    'this, but since this method will be replaced with a new version once ' +
-    'the component is mounted - you should be aware of the fact that this ' +
-    'method will soon be replaced.'
-  );
-};
+function invokeWithWarning(func) {
+  return function() {
+    console && console.warn && console.warn(
+      'You have invoked a method that is automatically bound, before the ' +
+        'instance has been mounted. There is nothing conceptually wrong with ' +
+        'this, but since this method will be replaced with a new version once' +
+        ' the component is mounted - you should be aware of the fact that ' +
+        'this method will soon be replaced.'
+    );
+    return func.apply(this, arguments);
+  };
+}
 
 /**
  * Policies that describe methods in `ReactCompositeComponentInterface`.
@@ -370,7 +372,10 @@ function mixSpecIntoComponent(Constructor, spec) {
           proto.__reactAutoBindMap = {};
         }
         proto.__reactAutoBindMap[name] = property;
-        proto[name] = invokedBeforeMount;
+        proto[name] = property;
+        if (__DEV__) {
+          proto[name] = invokeWithWarning(property);
+        }
       } else {
         if (isInherited) {
           // For methods which are defined more than once, call the existing
@@ -393,13 +398,13 @@ function mixSpecIntoComponent(Constructor, spec) {
  * @private
  */
 function createChainedFunction(one, two) {
-  return function chainedFunction(a, b, c, d, e, tooMany) {
+  return function chainedFunction(a, b, c, d, e, f, g, tooMany) {
     invariant(
       typeof tooMany === 'undefined',
-      'Chained function can only take a maximum of 5 arguments.'
+      'Chained function can only take a maximum of 7 arguments.'
     );
-    one.call(this, a, b, c, d, e);
-    two.call(this, a, b, c, d, e);
+    one.call(this, a, b, c, d, e, f, g);
+    two.call(this, a, b, c, d, e, f, g);
   };
 }
 
@@ -814,12 +819,12 @@ var ReactCompositeComponentMixin = {
    */
   _bindAutoBindMethod: function(method) {
     var component = this;
-    function autoBound(a, b, c, d, e, tooMany) {
+    function autoBound(a, b, c, d, e, f, g, tooMany) {
       invariant(
         typeof tooMany === 'undefined',
-        'React.autoBind(...): Methods can only take a maximum of 5 arguments.'
+        'React.autoBind(...): Methods can only take a maximum of 7 arguments.'
       );
-      return method.call(component, a, b, c, d, e);
+      return method.call(component, a, b, c, d, e, f, g);
     }
     return autoBound;
   }
diff --git a/src/core/__tests__/ReactCompositeComponent-test.js b/src/core/__tests__/ReactCompositeComponent-test.js
index d6623e9daa..ee48a4bcb1 100644
--- a/src/core/__tests__/ReactCompositeComponent-test.js
+++ b/src/core/__tests__/ReactCompositeComponent-test.js
@@ -188,15 +188,6 @@ describe('ReactCompositeComponent', function() {
     });
     var instance = <ComponentClass />;
 
-    // Autobound methods will throw before mounting.
-    // TODO: We should actually allow component instance methods to be invoked
-    // before mounting for read-only operations. We would then update this test.
-    expect(function() {
-      instance.methodToBeExplicitlyBound.bind(instance)();
-    }).toThrow();
-    expect(function() {
-      instance.methodAutoBound();
-    }).toThrow();
     expect(function() {
       instance.methodExplicitlyNotBound();
     }).not.toThrow();

From a62686622b4fbd2acd903d1879f77623373ff3bd Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 24 Jun 2013 16:09:35 -0700
Subject: [PATCH 49/94] Clean up naming

Fix a small style nit
---
 src/core/ReactComponent.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/core/ReactComponent.js b/src/core/ReactComponent.js
index f4333af4a6..5db60d5fc5 100644
--- a/src/core/ReactComponent.js
+++ b/src/core/ReactComponent.js
@@ -63,7 +63,7 @@ var CHILD_HAS_NO_IDENTITY =
 
 var CHILD_CAME_FROM_ANOTHER_OWNER = '. It was passed a child from ';
 
-var owner_has_warned = {};
+var ownerHasWarned = {};
 
 /**
  * Helpers for flattening child arguments onto a new array or use an existing
@@ -120,8 +120,8 @@ function assignKey(groupingIndex, child, index) {
         var childOwnerName =
           child.props[OWNER] && child.props[OWNER].constructor.displayName;
 
-        if (currentName && !owner_has_warned.hasOwnProperty(currentName)) {
-          owner_has_warned[currentName] = true;
+        if (currentName && !ownerHasWarned.hasOwnProperty(currentName)) {
+          ownerHasWarned[currentName] = true;
           var message = CHILD_HAS_NO_IDENTITY + currentName;
           if (childOwnerName && currentName !== childOwnerName) {
             // Usually the current owner is the offender, but if it accepts

From 7c60bb3e548980f3636190ecf08392d9f26aebb5 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 24 Jun 2013 16:09:38 -0700
Subject: [PATCH 50/94] Add unit test to prevent regression

The original autobinding diff made some assumptions about how methods were called on components that had to be reverted. This diff
enforces those assumptions in a test
---
 src/core/__tests__/ReactCompositeComponent-test.js | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/core/__tests__/ReactCompositeComponent-test.js b/src/core/__tests__/ReactCompositeComponent-test.js
index ee48a4bcb1..6bfd0b03d5 100644
--- a/src/core/__tests__/ReactCompositeComponent-test.js
+++ b/src/core/__tests__/ReactCompositeComponent-test.js
@@ -188,6 +188,14 @@ describe('ReactCompositeComponent', function() {
     });
     var instance = <ComponentClass />;
 
+    // These are controversial assertions for now, they just exist
+    // because existing code depends on these assumptions.
+    expect(function() {
+      instance.methodToBeExplicitlyBound.bind(instance)();
+    }).not.toThrow();
+    expect(function() {
+      instance.methodAutoBound();
+    }).not.toThrow();
     expect(function() {
       instance.methodExplicitlyNotBound();
     }).not.toThrow();

From 4f2d8dfe720aa5061ada4b027848b180a662b068 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 24 Jun 2013 16:09:43 -0700
Subject: [PATCH 51/94] Dynamic Input Component

Summary:
This is a proposal based loosely on the discussions I've had with @paulshen and @jwalke. It implements a shim for `React.DOM.input` (used as `<input>`) that supports two different use cases depending on whether `value` is provided or not.

If a `value` is //not// provided, the input will be initialized with the empty string (or `defaultValue`) and anytime the user changes the input, the `onChange` (or `onTextChange`) handler will be fired and the DOM will reflect the new changes.

  React.renderComponent(
    <input type="text" defaultValue="Untitled" onTextChange={handleChange} />,
    container
  );

If a `value` is provided, the input will be initialized to that value. Anytime the user changes the input, the `onChange` (or `onTextChange`) handler will be fired. However, the DOM will //not// reflect the new changes. If a `value` is provided, it is the responsibility of the owner to update the `value` prop passed in.

  var value = "Untitled";
  var input = React.renderComponent(
    <input type="text" value={value} onTextChange={handleChange} />,
    container
  );
  function handleChange(event) {
    // Do something cool like strip out non-numbers.
    var value = event.target.value.replace(/\D/g, '');
    input.setProps({value: value});
  }

This is just a start and we should build similar components for `textarea` and `select`. Also, this does not inject the new components because the changes are not backward compatible. Once we change all `<input>` uses to use `ReactDOMInput`, then we can inject.
---
 src/core/ReactDefaultInjection.js            |  11 +-
 src/{core => dom/components}/ReactDOMForm.js |   0
 src/dom/components/ReactDOMInput.js          | 123 +++++++++++++++++++
 3 files changed, 129 insertions(+), 5 deletions(-)
 rename src/{core => dom/components}/ReactDOMForm.js (100%)
 create mode 100644 src/dom/components/ReactDOMInput.js

diff --git a/src/core/ReactDefaultInjection.js b/src/core/ReactDefaultInjection.js
index 27fb2afba0..d67203aef8 100644
--- a/src/core/ReactDefaultInjection.js
+++ b/src/core/ReactDefaultInjection.js
@@ -45,14 +45,15 @@ function inject() {
     'TextChangeEventPlugin': TextChangeEventPlugin
   });
 
-  /*
-   * This is a bit of a hack. We need to override the <form> element
-   * to be a composite component because IE8 does not bubble or capture
-   * submit to the top level. In order to make this work with our
-   * dependency graph we need to inject it here.
+  /**
+   * This is a bit of a hack. We need to override the <form> element to be a
+   * composite component because IE8 does not bubble or capture submit to the
+   * top level. In order to make this work with our dependency graph we need to
+   * inject it here.
    */
   ReactDOM.injection.injectComponentClasses({
     form: ReactDOMForm
+    // TODO: Inject `ReactDOMInput`.
   });
 }
 
diff --git a/src/core/ReactDOMForm.js b/src/dom/components/ReactDOMForm.js
similarity index 100%
rename from src/core/ReactDOMForm.js
rename to src/dom/components/ReactDOMForm.js
diff --git a/src/dom/components/ReactDOMInput.js b/src/dom/components/ReactDOMInput.js
new file mode 100644
index 0000000000..9a0ca10160
--- /dev/null
+++ b/src/dom/components/ReactDOMInput.js
@@ -0,0 +1,123 @@
+/**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @providesModule ReactDOMInput
+ */
+
+"use strict";
+
+var DOMPropertyOperations = require('DOMPropertyOperations');
+var ReactCompositeComponent = require('ReactCompositeComponent');
+var ReactDOM = require('ReactDOM');
+
+var merge = require('merge');
+
+// Store a reference to the <input> `ReactNativeComponent`.
+var input = ReactDOM.input;
+
+/**
+ * Implements an <input> native component that allows setting these optional
+ * props: `checked`, `value`, `defaultChecked`, and `defaultValue`.
+ *
+ * If `checked` or `value` are not supplied (or null/undefined), user actions
+ * that affect the checked state or value will trigger updates to the element.
+ *
+ * If they are supplied (and not null/undefined), the rendered element will not
+ * trigger updates to the element. Instead, the props must change in order for
+ * the rendered element to be updated.
+ *
+ * The rendered element will be initialized as unchecked (or `defaultChecked`)
+ * with an empty value (or `defaultValue`).
+ *
+ * @see http://www.w3.org/TR/2012/WD-html5-20121025/the-input-element.html
+ */
+var ReactDOMInput = ReactCompositeComponent.createClass({
+
+  getInitialState: function() {
+    return {
+      checked: this.props.defaultChecked || false,
+      value: this.props.defaultValue || ''
+    };
+  },
+
+  getChecked: function() {
+    return this.props.checked != null ? this.props.checked : this.state.checked;
+  },
+
+  getValue: function() {
+    return this.props.value != null ? this.props.value : this.state.value;
+  },
+
+  render: function() {
+    // Clone `this.props` so we don't mutate the input.
+    var props = merge(this.props);
+
+    props.checked = this.getChecked();
+    props.value = this.getValue();
+
+    // TODO: Re-implement `onChange` with the implementation of `onTextChange`.
+    if (props.type === 'text' || props.type === 'password') {
+      props.onTextChange = this.handleTextChange;
+    } else {
+      props.onChange = this.handleChange;
+    }
+
+    return input(props, this.props.children);
+  },
+
+  componentDidUpdate: function(prevProps, prevState, rootNode) {
+    if (this.props.checked != null) {
+      DOMPropertyOperations.setValueForProperty(
+        rootNode,
+        'checked',
+        this.props.checked || false
+      );
+    }
+    if (this.props.value != null) {
+      DOMPropertyOperations.setValueForProperty(
+        rootNode,
+        'value',
+        this.props.value || ''
+      );
+    }
+  },
+
+  handleTextChange: ReactCompositeComponent.autoBind(function(event) {
+    var returnValue;
+    if (this.props.onTextChange) {
+      returnValue = this.props.onTextChange(event);
+    }
+    this.setState({
+      checked: event.target.checked,
+      value: event.target.value
+    });
+    return returnValue;
+  }),
+
+  handleChange: ReactCompositeComponent.autoBind(function(event) {
+    var returnValue;
+    if (this.props.onChange) {
+      returnValue = this.props.onChange(event);
+    }
+    this.setState({
+      checked: event.target.checked,
+      value: event.target.value
+    });
+    return returnValue;
+  })
+
+});
+
+module.exports = ReactDOMInput;

From 14102e8a4851119afe66866735d63d7901ab470f Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 24 Jun 2013 16:09:46 -0700
Subject: [PATCH 52/94] Fix isMounted() for composite components

This behavior seemed incorrect for composite components.

- isComponentMounted() represents ReactComponent's lifecycle of mounting
- isMounted() represents ReactCompositeComponent's lifecycle of isMounted()

Therefore, ReactComponents no longer have isMounted(). I think this is fine since it was not supposed to be public anyway.
---
 src/core/ReactCompositeComponent.js           | 22 +++++++++++++++----
 src/core/__tests__/ReactComponent-test.js     | 19 ++++++++++++++++
 .../__tests__/ReactCompositeComponent-test.js |  4 ++--
 3 files changed, 39 insertions(+), 6 deletions(-)

diff --git a/src/core/ReactCompositeComponent.js b/src/core/ReactCompositeComponent.js
index e97b5439fc..df9e5bbd78 100644
--- a/src/core/ReactCompositeComponent.js
+++ b/src/core/ReactCompositeComponent.js
@@ -326,8 +326,9 @@ function validateMethodOverride(proto, name) {
 function validateLifeCycleOnReplaceState(instance) {
   var compositeLifeCycleState = instance._compositeLifeCycleState;
   invariant(
-    instance.isMounted(),
-    'replaceState(...): Can only update a mounted component.'
+    instance.isMounted() ||
+      compositeLifeCycleState === CompositeLifeCycle.MOUNTING,
+    'replaceState(...): Can only update a mounted or mounting component.'
   );
   invariant(
     compositeLifeCycleState !== CompositeLifeCycle.RECEIVING_STATE &&
@@ -480,6 +481,17 @@ var ReactCompositeComponentMixin = {
       ReactCurrentOwner.getDepth() + 1 : 0;
   },
 
+  /**
+   * Checks whether or not this composite component is mounted.
+   * @return {boolean} True if mounted, false otherwise.
+   * @protected
+   * @final
+   */
+  isMounted: function() {
+    return ReactComponent.Mixin.isMounted.call(this) &&
+      this._compositeLifeCycleState !== CompositeLifeCycle.MOUNTING;
+  },
+
   /**
    * Initializes the component, renders markup, and registers event listeners.
    *
@@ -756,8 +768,10 @@ var ReactCompositeComponentMixin = {
   forceUpdate: function() {
     var compositeLifeCycleState = this._compositeLifeCycleState;
     invariant(
-      this.isMounted(),
-      'forceUpdate(...): Can only force an update on mounted components.'
+      this.isMounted() ||
+        compositeLifeCycleState === CompositeLifeCycle.MOUNTING,
+      'forceUpdate(...): Can only force an update on mounted or mounting ' +
+        'components.'
     );
     invariant(
       compositeLifeCycleState !== CompositeLifeCycle.RECEIVING_STATE &&
diff --git a/src/core/__tests__/ReactComponent-test.js b/src/core/__tests__/ReactComponent-test.js
index a753ce0c89..5b1d96a9e2 100644
--- a/src/core/__tests__/ReactComponent-test.js
+++ b/src/core/__tests__/ReactComponent-test.js
@@ -95,4 +95,23 @@ describe('ReactComponent', function() {
     ReactTestUtils.renderIntoDocument(instance);
   });
 
+  it('should correctly determine if a component is mounted', function() {
+    var Component = React.createClass({
+      componentWillMount: function() {
+        expect(this.isMounted()).toBeFalsy();
+      },
+      componentDidMount: function() {
+        expect(this.isMounted()).toBeTruthy();
+      },
+      render: function() {
+        return <div/>;
+      }
+    });
+
+    var instance = <Component />;
+
+    expect(instance.isMounted()).toBeFalsy();
+    ReactTestUtils.renderIntoDocument(instance);
+    expect(instance.isMounted()).toBeTruthy();
+  });
 });
diff --git a/src/core/__tests__/ReactCompositeComponent-test.js b/src/core/__tests__/ReactCompositeComponent-test.js
index 6bfd0b03d5..c9aad6498a 100644
--- a/src/core/__tests__/ReactCompositeComponent-test.js
+++ b/src/core/__tests__/ReactCompositeComponent-test.js
@@ -308,7 +308,7 @@ describe('ReactCompositeComponent', function() {
       instance.forceUpdate();
     }).toThrow(
       'Invariant Violation: forceUpdate(...): Can only force an update on ' +
-      'mounted components.'
+      'mounted or mounting components.'
     );
 
     React.renderComponent(instance, container);
@@ -321,7 +321,7 @@ describe('ReactCompositeComponent', function() {
       instance.forceUpdate();
     }).toThrow(
       'Invariant Violation: forceUpdate(...): Can only force an update on ' +
-      'mounted components.'
+      'mounted or mounting components.'
     );
   });
 

From 76ec746341b2ce3a98f8ca2183cfdd23fcd2d783 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 24 Jun 2013 16:09:50 -0700
Subject: [PATCH 53/94] Require Statement Nits

---
 src/core/ReactEventTopLevelCallback.js | 2 +-
 src/core/ReactInstanceHandles.js       | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/core/ReactEventTopLevelCallback.js b/src/core/ReactEventTopLevelCallback.js
index be70785073..25719e812c 100644
--- a/src/core/ReactEventTopLevelCallback.js
+++ b/src/core/ReactEventTopLevelCallback.js
@@ -21,9 +21,9 @@
 
 var ExecutionEnvironment = require('ExecutionEnvironment');
 var ReactEventEmitter = require('ReactEventEmitter');
+var ReactID = require('ReactID');
 var ReactInstanceHandles = require('ReactInstanceHandles');
 
-var ReactID = require('ReactID');
 var getEventTarget = require('getEventTarget');
 
 /**
diff --git a/src/core/ReactInstanceHandles.js b/src/core/ReactInstanceHandles.js
index 50564ac00c..dd8e68c219 100644
--- a/src/core/ReactInstanceHandles.js
+++ b/src/core/ReactInstanceHandles.js
@@ -20,6 +20,7 @@
 "use strict";
 
 var ReactID = require('ReactID');
+
 var invariant = require('invariant');
 
 var SEPARATOR = '.';

From de4084259759e7c70aad9583b2b2aadc82e41911 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 24 Jun 2013 16:09:54 -0700
Subject: [PATCH 54/94] Use `@return`, not `@returns`

---
 src/core/ReactID.js              | 2 +-
 src/dom/DOMChildrenOperations.js | 2 +-
 src/dom/Danger.js                | 2 +-
 src/event/EventPluginUtils.js    | 6 +++---
 src/utils/OrderedMap.js          | 4 ++--
 src/utils/Transaction.js         | 2 +-
 src/utils/accumulate.js          | 2 +-
 7 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/core/ReactID.js b/src/core/ReactID.js
index 9bfba32bfa..3ce1d42469 100644
--- a/src/core/ReactID.js
+++ b/src/core/ReactID.js
@@ -31,7 +31,7 @@ var nodeCache = {};
  * DOM node (such as window).
  *
  * @param {?DOMElement|DOMWindow|DOMDocument|DOMTextNode} node DOM node.
- * @returns {string} ID of the supplied `domNode`.
+ * @return {string} ID of the supplied `domNode`.
  */
 function getID(node) {
   if (node && node.getAttributeNode) {
diff --git a/src/dom/DOMChildrenOperations.js b/src/dom/DOMChildrenOperations.js
index ce0f762a39..b1562e8e79 100644
--- a/src/dom/DOMChildrenOperations.js
+++ b/src/dom/DOMChildrenOperations.js
@@ -47,7 +47,7 @@ var REMOVE_AT = keyOf({removeAt: null});
  *
  * @param {Element} parent Parent DOM node.
  * @param {Object} childOperations Description of child operations.
- * @returns {Array?} Sparse array containing elements by their current index in
+ * @return {Array?} Sparse array containing elements by their current index in
  * the DOM.
  */
 var _getNodesByOriginalIndex = function(parent, childOperations) {
diff --git a/src/dom/Danger.js b/src/dom/Danger.js
index 1181739679..21fd331fa6 100644
--- a/src/dom/Danger.js
+++ b/src/dom/Danger.js
@@ -65,7 +65,7 @@ function getParentDummy(parent) {
  * @param {Element} elem Parent element.
  * @param {Element} insert Element to insert.
  * @param {Element} after Element to insert after.
- * @returns {Element} Element that was inserted.
+ * @return {Element} Element that was inserted.
  */
 function insertNodeAfterNode(elem, insert, after) {
   if (__DEV__) {
diff --git a/src/event/EventPluginUtils.js b/src/event/EventPluginUtils.js
index 686f7073eb..c9d063f620 100644
--- a/src/event/EventPluginUtils.js
+++ b/src/event/EventPluginUtils.js
@@ -106,7 +106,7 @@ function executeDispatchesInOrder(event, executeDispatch) {
  * Standard/simple iteration through an event's collected dispatches, but stops
  * at the first dispatch execution returning true, and returns that id.
  *
- * @returns id of the first dispatch execution who's listener returns true, or
+ * @return id of the first dispatch execution who's listener returns true, or
  * null if no listener returned true.
  */
 function executeDispatchesInOrderStopAtTrue(event) {
@@ -140,7 +140,7 @@ function executeDispatchesInOrderStopAtTrue(event) {
  * return values at each dispatch execution, but it does tend to make sense when
  * dealing with "direct" dispatches.
  *
- * @returns The return value of executing the single dispatch.
+ * @return The return value of executing the single dispatch.
  */
 function executeDirectDispatch(event) {
   if (__DEV__) {
@@ -162,7 +162,7 @@ function executeDirectDispatch(event) {
 
 /**
  * @param {SyntheticEvent} event
- * @returns {bool} True iff number of dispatches accumulated is greater than 0.
+ * @return {bool} True iff number of dispatches accumulated is greater than 0.
  */
 function hasDispatches(event) {
   return !!event._dispatchListeners;
diff --git a/src/utils/OrderedMap.js b/src/utils/OrderedMap.js
index 429ddf8307..b4ea88216f 100644
--- a/src/utils/OrderedMap.js
+++ b/src/utils/OrderedMap.js
@@ -246,7 +246,7 @@ var OrderedMapMethods = {
    *
    * @param {Function} cb Callback to invoke for each item.
    * @param {Object?=} context Context to invoke callback from.
-   * @returns {OrderedMap} OrderedMap that results from mapping.
+   * @return {OrderedMap} OrderedMap that results from mapping.
    */
   map: function(cb, context) {
     return this.mapRange(cb, 0, this.length, context);
@@ -288,7 +288,7 @@ var OrderedMapMethods = {
    *
    * @param {Function} cb Callback to invoke for each item.
    * @param {Object?=} context Context to invoke callback from.
-   * @returns {OrderedMap} OrderedMap that results from filtering.
+   * @return {OrderedMap} OrderedMap that results from filtering.
    */
   filter: function(cb, context) {
     return this.filterRange(cb, 0, this.length, context);
diff --git a/src/utils/Transaction.js b/src/utils/Transaction.js
index a851e81f32..8e630d88ab 100644
--- a/src/utils/Transaction.js
+++ b/src/utils/Transaction.js
@@ -153,7 +153,7 @@ var Mixin = {
    * @param {Object} scope Scope to invoke from.
    * @param {Object?=} args... Arguments to pass to the method (optional).
    *                           Helps prevent need to bind in many cases.
-   * @returns Return value from `method`.
+   * @return Return value from `method`.
    */
   perform: function(method, scope, a, b, c, d, e, f) {
     throwIf(this.isInTransaction(), DUAL_TRANSACTION);
diff --git a/src/utils/accumulate.js b/src/utils/accumulate.js
index e87a8a3b6b..86f58b966a 100644
--- a/src/utils/accumulate.js
+++ b/src/utils/accumulate.js
@@ -35,7 +35,7 @@ if (__DEV__) {
  * depending on the total count (if greater than one, an array is allocated).
  * Handles most common case first (starting with an empty current value and
  * acquiring one).
- * @returns {Accumulation} An accumulation which is either a single item or an
+ * @return {Accumulation} An accumulation which is either a single item or an
  * Array of items.
  */
 function accumulate(cur, next) {

From f0a4ca5f69a4c0bffe40aa26335a7171ab6e7883 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 24 Jun 2013 16:49:12 -0700
Subject: [PATCH 55/94] Remove React.autoBind entirely

---
 src/core/__tests__/ReactBind-test.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/core/__tests__/ReactBind-test.js b/src/core/__tests__/ReactBind-test.js
index 4d31f38ab0..47e77bb9d8 100644
--- a/src/core/__tests__/ReactBind-test.js
+++ b/src/core/__tests__/ReactBind-test.js
@@ -40,7 +40,7 @@ describe('React.autoBind', function() {
       },
       onMouseEnter: ReactDoNotBindDeprecated.doNotBind(mouseDidEnter),
       onMouseLeave: ReactDoNotBindDeprecated.doNotBind(mouseDidLeave),
-      onClick: React.autoBind(mouseDidClick),
+      onClick: mouseDidClick,
 
       // auto binding only occurs on top level functions in class defs.
       badIdeas: {
@@ -110,7 +110,7 @@ describe('React.autoBind', function() {
     var mouseDidClick = mocks.getMockFunction();
 
     var TestMixin = {
-      onClick: React.autoBind(mouseDidClick)
+      onClick: mouseDidClick
     };
 
     var TestBindComponent = React.createClass({

From 6bbcbc08cf5e2af9e9c0d0cde75148880df69fd8 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 24 Jun 2013 16:49:16 -0700
Subject: [PATCH 56/94] Rename `BrowserEnv` to `ViewportMetrics`

Becuase that's what it is.
---
 src/core/ReactEventEmitter.js                 |  4 ++--
 .../BrowserEnv.js => dom/ViewportMetrics.js}  | 20 +++++++++----------
 src/event/synthetic/SyntheticMouseEvent.js    |  6 +++---
 src/eventPlugins/TapEventPlugin.js            |  4 ++--
 4 files changed, 17 insertions(+), 17 deletions(-)
 rename src/{core/BrowserEnv.js => dom/ViewportMetrics.js} (73%)

diff --git a/src/core/ReactEventEmitter.js b/src/core/ReactEventEmitter.js
index ed552fc4d9..65f5072bbf 100644
--- a/src/core/ReactEventEmitter.js
+++ b/src/core/ReactEventEmitter.js
@@ -19,11 +19,11 @@
 
 "use strict";
 
-var BrowserEnv = require('BrowserEnv');
 var EventConstants = require('EventConstants');
 var EventListener = require('EventListener');
 var EventPluginHub = require('EventPluginHub');
 var ExecutionEnvironment = require('ExecutionEnvironment');
+var ViewportMetrics = require('ViewportMetrics');
 
 var invariant = require('invariant');
 var isEventSupported = require('isEventSupported');
@@ -126,7 +126,7 @@ function trapCapturedEvent(topLevelType, handlerBaseName, element) {
  * @see http://www.quirksmode.org/dom/events/scroll.html
  */
 function registerScrollValueMonitoring() {
-  var refresh = BrowserEnv.refreshAuthoritativeScrollValues;
+  var refresh = ViewportMetrics.refreshScrollValues;
   EventListener.listen(window, 'scroll', refresh);
   EventListener.listen(window, 'resize', refresh);
 }
diff --git a/src/core/BrowserEnv.js b/src/dom/ViewportMetrics.js
similarity index 73%
rename from src/core/BrowserEnv.js
rename to src/dom/ViewportMetrics.js
index 53937a4ada..e9f2d3d1e0 100644
--- a/src/core/BrowserEnv.js
+++ b/src/dom/ViewportMetrics.js
@@ -13,24 +13,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * @providesModule BrowserEnv
+ * @providesModule ViewportMetrics
  */
 
 "use strict";
 
-/**
- * A place to share/cache browser/chrome level computations.
- */
-var BrowserEnv = {
+var ViewportMetrics = {
+
   currentScrollLeft: 0,
+
   currentScrollTop: 0,
-  browserInfo: null,
-  refreshAuthoritativeScrollValues: function() {
-    BrowserEnv.currentScrollLeft =
+
+  refreshScrollValues: function() {
+    ViewportMetrics.currentScrollLeft =
       document.body.scrollLeft + document.documentElement.scrollLeft;
-    BrowserEnv.currentScrollTop =
+    ViewportMetrics.currentScrollTop =
       document.body.scrollTop + document.documentElement.scrollTop;
   }
+
 };
 
-module.exports = BrowserEnv;
+module.exports = ViewportMetrics;
diff --git a/src/event/synthetic/SyntheticMouseEvent.js b/src/event/synthetic/SyntheticMouseEvent.js
index 6272fbb83a..5e5dd8ded8 100644
--- a/src/event/synthetic/SyntheticMouseEvent.js
+++ b/src/event/synthetic/SyntheticMouseEvent.js
@@ -19,8 +19,8 @@
 
 "use strict";
 
-var BrowserEnv = require('BrowserEnv');
 var SyntheticUIEvent = require('SyntheticUIEvent');
+var ViewportMetrics = require('ViewportMetrics');
 
 /**
  * @interface MouseEvent
@@ -61,12 +61,12 @@ var MouseEventInterface = {
   pageX: function(event) {
     return 'pageX' in event ?
       event.pageX :
-      event.clientX + BrowserEnv.currentPageScrollLeft;
+      event.clientX + ViewportMetrics.currentPageScrollLeft;
   },
   pageY: function(event) {
     return 'pageY' in event ?
       event.pageY :
-      event.clientY + BrowserEnv.currentPageScrollTop;
+      event.clientY + ViewportMetrics.currentPageScrollTop;
   }
 };
 
diff --git a/src/eventPlugins/TapEventPlugin.js b/src/eventPlugins/TapEventPlugin.js
index 03293eaf16..75409ab4b3 100644
--- a/src/eventPlugins/TapEventPlugin.js
+++ b/src/eventPlugins/TapEventPlugin.js
@@ -19,11 +19,11 @@
 
 "use strict";
 
-var BrowserEnv = require('BrowserEnv');
 var EventPluginUtils = require('EventPluginUtils');
 var EventPropagators = require('EventPropagators');
 var SyntheticUIEvent = require('SyntheticUIEvent');
 var TouchEventUtils = require('TouchEventUtils');
+var ViewportMetrics = require('ViewportMetrics');
 
 var keyOf = require('keyOf');
 
@@ -49,7 +49,7 @@ function getAxisCoordOfEvent(axis, nativeEvent) {
   }
   return axis.page in nativeEvent ?
     nativeEvent[axis.page] :
-    nativeEvent[axis.client] + BrowserEnv[axis.envScroll];
+    nativeEvent[axis.client] + ViewportMetrics[axis.envScroll];
 }
 
 function getDistance(coords, nativeEvent) {

From bd8ecc1caa59dba79d79a126343a666ef4513582 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 24 Jun 2013 18:27:32 -0700
Subject: [PATCH 57/94] Restore @spicyj's lifecycle tests

These got lost in a rebase.
---
 .../__tests__/ReactComponentLifeCycle-test.js | 64 +++++++++++++++++++
 1 file changed, 64 insertions(+)

diff --git a/src/core/__tests__/ReactComponentLifeCycle-test.js b/src/core/__tests__/ReactComponentLifeCycle-test.js
index a3c18be304..3f2df5e82e 100644
--- a/src/core/__tests__/ReactComponentLifeCycle-test.js
+++ b/src/core/__tests__/ReactComponentLifeCycle-test.js
@@ -434,5 +434,69 @@ describe('ReactComponentLifeCycle', function() {
     expect(instance.state.stateField).toBe('goodbye');
   });
 
+  it('should call nested lifecycle methods in the right order', function() {
+    var log;
+    var logger = function(msg) {
+      return function() {
+        // return true for shouldComponentUpdate
+        log.push(msg);
+        return true;
+      };
+    };
+    var Outer = React.createClass({
+      render: function() {
+        return <div><Inner x={this.props.x} /></div>;
+      },
+      componentWillMount: logger('outer componentWillMount'),
+      componentDidMount: logger('outer componentDidMount'),
+      componentWillReceiveProps: logger('outer componentWillReceiveProps'),
+      shouldComponentUpdate: logger('outer shouldComponentUpdate'),
+      componentWillUpdate: logger('outer componentWillUpdate'),
+      componentDidUpdate: logger('outer componentDidUpdate'),
+      componentWillUnmount: logger('outer componentWillUnmount')
+    });
+    var Inner = React.createClass({
+      render: function() {
+        return <span>{this.props.x}</span>;
+      },
+      componentWillMount: logger('inner componentWillMount'),
+      componentDidMount: logger('inner componentDidMount'),
+      componentWillReceiveProps: logger('inner componentWillReceiveProps'),
+      shouldComponentUpdate: logger('inner shouldComponentUpdate'),
+      componentWillUpdate: logger('inner componentWillUpdate'),
+      componentDidUpdate: logger('inner componentDidUpdate'),
+      componentWillUnmount: logger('inner componentWillUnmount')
+    });
+    var instance;
+
+    log = [];
+    instance = ReactTestUtils.renderIntoDocument(<Outer x={17} />);
+    expect(log).toEqual([
+      'outer componentWillMount',
+      'inner componentWillMount',
+      'inner componentDidMount',
+      'outer componentDidMount'
+    ]);
+
+    log = [];
+    instance.setProps({x: 42});
+    expect(log).toEqual([
+      'outer componentWillReceiveProps',
+      'outer shouldComponentUpdate',
+      'outer componentWillUpdate',
+      'inner componentWillReceiveProps',
+      'inner shouldComponentUpdate',
+      'inner componentWillUpdate',
+      'inner componentDidUpdate',
+      'outer componentDidUpdate'
+    ]);
+
+    log = [];
+    instance.unmountComponent();
+    expect(log).toEqual([
+      'outer componentWillUnmount',
+      'inner componentWillUnmount'
+    ]);
+  });
 });
 

From c1886c651365e1db415a9efd2d4e621eea20cf32 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 24 Jun 2013 18:27:35 -0700
Subject: [PATCH 58/94] Use ReactID.ATTR_NAME as the React-specific ID
 attribute name.

Another step in the plan towards making `ReactID.ATTR_NAME` the central
source of truth regarding the React-specific ID attribute name.
---
 src/core/ReactID.js                           |  1 +
 src/core/ReactMount.js                        |  1 +
 src/core/ReactNativeComponent.js              |  3 ++-
 src/core/ReactTextComponent.js                |  3 ++-
 .../__tests__/ReactServerRendering-test.js    | 19 ++++++++++++++-----
 5 files changed, 20 insertions(+), 7 deletions(-)

diff --git a/src/core/ReactID.js b/src/core/ReactID.js
index 3ce1d42469..ea59e0b09b 100644
--- a/src/core/ReactID.js
+++ b/src/core/ReactID.js
@@ -120,6 +120,7 @@ function purgeEntireCache() {
   nodeCache = {};
 }
 
+exports.ATTR_NAME = ATTR_NAME;
 exports.getID = getID;
 exports.setID = setID;
 exports.getNode = getNode;
diff --git a/src/core/ReactMount.js b/src/core/ReactMount.js
index 2d9ddfcdb5..ae6f263f19 100644
--- a/src/core/ReactMount.js
+++ b/src/core/ReactMount.js
@@ -55,6 +55,7 @@ function getReactRootID(container) {
  *
  *   ReactMount.renderComponent(component, $('container'));
  *
+ *   TODO Update this comment when ReactID.ATTR_NAME changes.
  *   <div id="container">         <-- Supplied `container`.
  *     <div id=".reactRoot[3]">   <-- Rendered reactRoot of React component.
  *       // ...
diff --git a/src/core/ReactNativeComponent.js b/src/core/ReactNativeComponent.js
index 07371b2c8f..eddb27ec5f 100644
--- a/src/core/ReactNativeComponent.js
+++ b/src/core/ReactNativeComponent.js
@@ -24,6 +24,7 @@ var DOMPropertyOperations = require('DOMPropertyOperations');
 var ReactComponent = require('ReactComponent');
 var ReactEventEmitter = require('ReactEventEmitter');
 var ReactMultiChild = require('ReactMultiChild');
+var ReactID = require('ReactID');
 
 var escapeTextForBrowser = require('escapeTextForBrowser');
 var flattenChildren = require('flattenChildren');
@@ -138,7 +139,7 @@ ReactNativeComponent.Mixin = {
       }
     }
 
-    return ret + ' id="' + this._rootNodeID + '">';
+    return ret + ' ' + ReactID.ATTR_NAME + '="' + this._rootNodeID + '">';
   },
 
   /**
diff --git a/src/core/ReactTextComponent.js b/src/core/ReactTextComponent.js
index 4b7aa495ac..57e56bbce2 100644
--- a/src/core/ReactTextComponent.js
+++ b/src/core/ReactTextComponent.js
@@ -20,6 +20,7 @@
 "use strict";
 
 var ReactComponent = require('ReactComponent');
+var ReactID = require('ReactID');
 
 var escapeTextForBrowser = require('escapeTextForBrowser');
 var mixInto = require('mixInto');
@@ -57,7 +58,7 @@ mixInto(ReactTextComponent, {
   mountComponent: function(rootID) {
     ReactComponent.Mixin.mountComponent.call(this, rootID);
     return (
-      '<span id="' + rootID + '">' +
+      '<span ' + ReactID.ATTR_NAME + '="' + rootID + '">' +
         escapeTextForBrowser(this.props.text) +
       '</span>'
     );
diff --git a/src/environment/__tests__/ReactServerRendering-test.js b/src/environment/__tests__/ReactServerRendering-test.js
index ebbad6b4b0..c8cc58ebe5 100644
--- a/src/environment/__tests__/ReactServerRendering-test.js
+++ b/src/environment/__tests__/ReactServerRendering-test.js
@@ -24,10 +24,12 @@
 require('mock-modules')
   .dontMock('ExecutionEnvironment')
   .dontMock('React')
+  .dontMock('ReactID')
   .dontMock('ReactServerRendering')
   .dontMock('ReactTestUtils');
 
 var React;
+var ReactID;
 var ReactTestUtils;
 var ReactServerRendering;
 var ExecutionEnvironment;
@@ -36,6 +38,7 @@ describe('ReactServerRendering', function() {
   beforeEach(function() {
     require('mock-modules').dumpCache();
     React = require('React');
+    ReactID = require('ReactID');
     ReactTestUtils = require('ReactTestUtils');
     ExecutionEnvironment = require('ExecutionEnvironment');
     ExecutionEnvironment.canUseDOM = false;
@@ -51,7 +54,7 @@ describe('ReactServerRendering', function() {
       }
     );
     expect(response).toMatch(
-      '<span  id="[^"]+">hello world</span>'
+      '<span  ' + ReactID.ATTR_NAME + '="[^"]+">hello world</span>'
     );
   });
 
@@ -74,8 +77,12 @@ describe('ReactServerRendering', function() {
       }
     );
     expect(response).toMatch(
-      '<div  id="[^"]+"><span  id="[^"]+"><span id="[^"]+">My name is </span>' +
-        '<span id="[^"]+">child</span></span></div>'
+      '<div  ' + ReactID.ATTR_NAME + '="[^"]+">' +
+        '<span  ' + ReactID.ATTR_NAME + '="[^"]+">' +
+          '<span ' + ReactID.ATTR_NAME + '="[^"]+">My name is </span>' +
+          '<span ' + ReactID.ATTR_NAME + '="[^"]+">child</span>' +
+        '</span>' +
+      '</div>'
     );
   });
 
@@ -123,8 +130,10 @@ describe('ReactServerRendering', function() {
     );
 
     expect(response).toMatch(
-      '<span  id="[^"]+"><span id="[^"]+">Component name: </span>' +
-        '<span id="[^"]+">TestComponent</span></span>'
+      '<span  ' + ReactID.ATTR_NAME + '="[^"]+">' +
+        '<span ' + ReactID.ATTR_NAME + '="[^"]+">Component name: </span>' +
+        '<span ' + ReactID.ATTR_NAME + '="[^"]+">TestComponent</span>' +
+      '</span>'
     );
     expect(lifecycle).toEqual(
       ['getInitialState', 'componentWillMount', 'render']

From b282a0f4f16bc86ef821f82dcf720385116f0989 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Paul=20O=E2=80=99Shannessy?= <paul@oshannessy.com>
Date: Mon, 24 Jun 2013 16:38:21 -0700
Subject: [PATCH 59/94] The compare_size cache gets wiped out with `grunt
 clean`

`.grunt/` is the directory that is suggested for storing task related
files, and this file is not useful if it gets wiped out often. So I'm
moving the compare_size cache into `.grunt/` so we keep it around
longer.
---
 grunt/config/compare_size.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/grunt/config/compare_size.js b/grunt/config/compare_size.js
index e785fe5281..fb59d94cdb 100644
--- a/grunt/config/compare_size.js
+++ b/grunt/config/compare_size.js
@@ -12,6 +12,6 @@ module.exports = {
         return gzip.zip(contents, {}).length;
       }
     },
-    cache: "build/.sizecache.json"
+    cache: ".grunt/sizecache.json"
   }
 };

From f6c4d2d16110e45bc9969cf6ad42290dd4d09c60 Mon Sep 17 00:00:00 2001
From: Ben Alpert <spicyjalapeno@gmail.com>
Date: Wed, 19 Jun 2013 00:23:33 -0700
Subject: [PATCH 60/94] Check that `container` is a valid DOM element

---
 src/core/ReactComponent.js                |  4 ++++
 src/core/ReactMount.js                    |  2 +-
 src/core/__tests__/ReactComponent-test.js | 18 ++++++++++++++++++
 3 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/src/core/ReactComponent.js b/src/core/ReactComponent.js
index 530a6f9c66..94507b6968 100644
--- a/src/core/ReactComponent.js
+++ b/src/core/ReactComponent.js
@@ -511,6 +511,10 @@ var ReactComponent = {
         container,
         transaction,
         shouldReuseMarkup) {
+      invariant(
+        container && container.nodeType === 1,
+        'mountComponentIntoNode(...): Target container is not a DOM element.'
+      );
       var renderStart = Date.now();
       var markup = this.mountComponent(rootID, transaction);
       ReactMount.totalInstantiationTime += (Date.now() - renderStart);
diff --git a/src/core/ReactMount.js b/src/core/ReactMount.js
index 6eaf42cfd6..f11c509142 100644
--- a/src/core/ReactMount.js
+++ b/src/core/ReactMount.js
@@ -35,7 +35,7 @@ var containersByReactRootID = {};
  * @return {?*} DOM element that may have the reactRoot ID, or null.
  */
 function getReactRootElementInContainer(container) {
-  return container.firstChild;
+  return container && container.firstChild;
 }
 
 /**
diff --git a/src/core/__tests__/ReactComponent-test.js b/src/core/__tests__/ReactComponent-test.js
index a753ce0c89..2dbe49aedb 100644
--- a/src/core/__tests__/ReactComponent-test.js
+++ b/src/core/__tests__/ReactComponent-test.js
@@ -31,6 +31,24 @@ describe('ReactComponent', function() {
     reactComponentExpect = require('reactComponentExpect');
   });
 
+  it('should throw on invalid render targets', function() {
+    var container = document.createElement('div');
+    // jQuery objects are basically arrays; people often pass them in by mistake
+    expect(function() {
+      React.renderComponent(<div></div>, [container]);
+    }).toThrow(
+      'Invariant Violation: mountComponentIntoNode(...): Target container is ' +
+      'not a DOM element.'
+    );
+
+    expect(function() {
+      React.renderComponent(<div></div>, null);
+    }).toThrow(
+      'Invariant Violation: mountComponentIntoNode(...): Target container is ' +
+      'not a DOM element.'
+    );
+  });
+
   it('should throw when supplying a ref outside of render method', function() {
     var instance = <div ref="badDiv" />;
     expect(function() {

From 1c40dde7825e7d8863d69357dbd7013f926e35f6 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Tue, 25 Jun 2013 13:56:41 -0700
Subject: [PATCH 61/94] Remove ReactID.primeTree in favor of priming in
 ReactID.getID.

Although it would have been nice to prime the entire tree and achieve a
cache hit rate of 100%, that cost would have to be paid up front, during
page rendering.

This patch avoids priming up front in favor of making the most of the work
done by `ReactMount.findReactRenderedDOMNodeSlow`, which calls
`ReactID.getID` while traversing the rendered DOM. The insight is this: if
`getID` simply primes the cache whenever it finds a new ID, then
`findReactRenderedDOMNodeSlow` will end up priming quite a few more nodes
that are actually involved in `ReactID.getNode` lookups, and we won't need
`primeTree` at all.
---
 src/core/ReactID.js | 37 ++++++++++---------------------------
 1 file changed, 10 insertions(+), 27 deletions(-)

diff --git a/src/core/ReactID.js b/src/core/ReactID.js
index ea59e0b09b..f791285557 100644
--- a/src/core/ReactID.js
+++ b/src/core/ReactID.js
@@ -36,7 +36,16 @@ var nodeCache = {};
 function getID(node) {
   if (node && node.getAttributeNode) {
     var attributeNode = node.getAttributeNode(ATTR_NAME);
-    return attributeNode && attributeNode.value || '';
+    if (attributeNode) {
+      var id = attributeNode.value;
+      if (id) {
+        // Assume that any node previously cached with this ID has since
+        // become invalid and should be replaced. TODO Enforce this.
+        nodeCache[id] = node;
+
+        return id;
+      }
+    }
   }
 
   return '';
@@ -79,31 +88,6 @@ function getNode(id) {
   return null;
 }
 
-/**
- * Efficiently finds all nodes with a React-specific ID and primes the
- * cache so that getNode lookups take constant time.
- *
- * @param {DOMElement} root The root element to scan.
- */
-function primeTree(root) {
-  var nodes = root.querySelectorAll
-    ? root.querySelectorAll('[' + ATTR_NAME + ']')
-    : root.getElementsByTagName('*');
-
-  for (var i = 0; i < nodes.length; ++i) {
-    prime(nodes.item(i));
-  }
-
-  prime(root);
-}
-
-function prime(node) {
-  var attributeNode = node.getAttributeNode(ATTR_NAME);
-  if (attributeNode) {
-    nodeCache[attributeNode.value] = node;
-  }
-}
-
 /**
  * Causes the cache to forget about one React-specific ID.
  *
@@ -124,6 +108,5 @@ exports.ATTR_NAME = ATTR_NAME;
 exports.getID = getID;
 exports.setID = setID;
 exports.getNode = getNode;
-exports.primeTree = primeTree;
 exports.purgeID = purgeID;
 exports.purgeEntireCache = purgeEntireCache;

From 1d65f81b1617e339f36fad285bc45f805bb899f2 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Tue, 25 Jun 2013 13:56:48 -0700
Subject: [PATCH 62/94] Remove ReactDOMNodeCache and getDOMNodeID.

These modules have been superseded by `ReactID`. Since they were only used
internally, and I have updated all client code that previously assumed
their existence, I believe they can be dropped for good.
---
 src/core/ReactDOMNodeCache.js | 26 --------------------------
 src/dom/getDOMNodeID.js       | 27 ---------------------------
 2 files changed, 53 deletions(-)
 delete mode 100644 src/core/ReactDOMNodeCache.js
 delete mode 100644 src/dom/getDOMNodeID.js

diff --git a/src/core/ReactDOMNodeCache.js b/src/core/ReactDOMNodeCache.js
deleted file mode 100644
index 908c2ddbcd..0000000000
--- a/src/core/ReactDOMNodeCache.js
+++ /dev/null
@@ -1,26 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactDOMNodeCache
- * @typechecks
- */
-
-"use strict";
-
-var ReactID = require('ReactID');
-
-exports.getNodeByID = ReactID.getNode;
-exports.purgeID = ReactID.purgeID;
-exports.purgeEntireCache = ReactID.purgeEntireCache;
diff --git a/src/dom/getDOMNodeID.js b/src/dom/getDOMNodeID.js
deleted file mode 100644
index dddd6fadee..0000000000
--- a/src/dom/getDOMNodeID.js
+++ /dev/null
@@ -1,27 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule getDOMNodeID
- * @typechecks
- */
-
-"use strict";
-
-var ReactID = require('ReactID');
-
-function getDOMNodeID(domNode) {
-  return ReactID.getID(domNode);
-}
-module.exports = getDOMNodeID;

From fb6381fb35c8af868b5134c3d7a91699a7d01090 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Tue, 25 Jun 2013 13:56:51 -0700
Subject: [PATCH 63/94] Upgrade TextChangeEventPlugin to ChangeEventPlugin and
 support more form elements

Upgrade `TextChangeEventPlugin` to be the `onChange` event that React
fires. In React, `onChange` will now fire when `input` fires for form elements in
modern browsers.

Handle this for:

  input[type=text]
  input[type=password]
  input[type=checkbox]
  input[type=radio]
  textarea
  select

Support:

- OSX Chrome
- OSX Safari
- OSX Firefox
- Win 7 / IE8
- Win 7 / IE9
- Win 7 / IE10

Everything works but caret selection / placement differs from browser to
browser.

For <select> elements, the event is fired with `change`. This is a
conscious decision, even though in some browsers (OSX firefox, IE), it
can be argued that the event should fire more due to how the UI looks.

Builds on https://github.com/facebook/react/pull/75, which handled only
text inputs.
---
 src/core/ReactDefaultInjection.js             |   4 +-
 src/dom/components/ReactDOMInput.js           |  20 +-
 ...ngeEventPlugin.js => ChangeEventPlugin.js} | 241 +++++++++++++-----
 src/eventPlugins/DefaultEventPluginOrder.js   |   2 +-
 src/eventPlugins/SimpleEventPlugin.js         |   8 -
 5 files changed, 184 insertions(+), 91 deletions(-)
 rename src/eventPlugins/{TextChangeEventPlugin.js => ChangeEventPlugin.js} (56%)

diff --git a/src/core/ReactDefaultInjection.js b/src/core/ReactDefaultInjection.js
index d67203aef8..96fb625f94 100644
--- a/src/core/ReactDefaultInjection.js
+++ b/src/core/ReactDefaultInjection.js
@@ -23,7 +23,7 @@ var ReactDOMForm = require('ReactDOMForm');
 
 var DefaultEventPluginOrder = require('DefaultEventPluginOrder');
 var EnterLeaveEventPlugin = require('EnterLeaveEventPlugin');
-var TextChangeEventPlugin = require('TextChangeEventPlugin');
+var ChangeEventPlugin = require('ChangeEventPlugin');
 var EventPluginHub = require('EventPluginHub');
 var ReactInstanceHandles = require('ReactInstanceHandles');
 var SimpleEventPlugin = require('SimpleEventPlugin');
@@ -42,7 +42,7 @@ function inject() {
   EventPluginHub.injection.injectEventPluginsByName({
     'SimpleEventPlugin': SimpleEventPlugin,
     'EnterLeaveEventPlugin': EnterLeaveEventPlugin,
-    'TextChangeEventPlugin': TextChangeEventPlugin
+    'ChangeEventPlugin': ChangeEventPlugin
   });
 
   /**
diff --git a/src/dom/components/ReactDOMInput.js b/src/dom/components/ReactDOMInput.js
index 9a0ca10160..ad3c500ef1 100644
--- a/src/dom/components/ReactDOMInput.js
+++ b/src/dom/components/ReactDOMInput.js
@@ -66,13 +66,7 @@ var ReactDOMInput = ReactCompositeComponent.createClass({
 
     props.checked = this.getChecked();
     props.value = this.getValue();
-
-    // TODO: Re-implement `onChange` with the implementation of `onTextChange`.
-    if (props.type === 'text' || props.type === 'password') {
-      props.onTextChange = this.handleTextChange;
-    } else {
-      props.onChange = this.handleChange;
-    }
+    props.onChange = this.handleChange;
 
     return input(props, this.props.children);
   },
@@ -94,18 +88,6 @@ var ReactDOMInput = ReactCompositeComponent.createClass({
     }
   },
 
-  handleTextChange: ReactCompositeComponent.autoBind(function(event) {
-    var returnValue;
-    if (this.props.onTextChange) {
-      returnValue = this.props.onTextChange(event);
-    }
-    this.setState({
-      checked: event.target.checked,
-      value: event.target.value
-    });
-    return returnValue;
-  }),
-
   handleChange: ReactCompositeComponent.autoBind(function(event) {
     var returnValue;
     if (this.props.onChange) {
diff --git a/src/eventPlugins/TextChangeEventPlugin.js b/src/eventPlugins/ChangeEventPlugin.js
similarity index 56%
rename from src/eventPlugins/TextChangeEventPlugin.js
rename to src/eventPlugins/ChangeEventPlugin.js
index 1502c38098..8dca1bb05c 100644
--- a/src/eventPlugins/TextChangeEventPlugin.js
+++ b/src/eventPlugins/ChangeEventPlugin.js
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * @providesModule TextChangeEventPlugin
+ * @providesModule ChangeEventPlugin
  */
 
 "use strict";
@@ -30,41 +30,125 @@ var keyOf = require('keyOf');
 var topLevelTypes = EventConstants.topLevelTypes;
 
 var eventTypes = {
-  textChange: {
+  change: {
     phasedRegistrationNames: {
-      bubbled: keyOf({onTextChange: null}),
-      captured: keyOf({onTextChangeCapture: null})
+      bubbled: keyOf({onChange: null}),
+      captured: keyOf({onChangeCapture: null})
     }
   }
 };
 
-var isInputSupported;
-if (ExecutionEnvironment.canUseDOM) {
-  // IE9 claims to support the input event but fails to trigger it when
-  // deleting text, so we ignore its input events
-  isInputSupported = isEventSupported('input') && (
-    !("documentMode" in document) || document.documentMode > 9
-  );
-}
-
-var hasInputCapabilities = function(elem) {
-  // The HTML5 spec lists many more types than `text` and `password` on which
-  // the input event is triggered but none of them exist in old IE, so we don't
-  // check them here.
-  // TODO: <textarea> should be supported too but IE seems to reset the
-  // selection when changing textarea contents during a selectionchange event
-  // so it's not listed here for now.
-  return (
-    elem.nodeName === 'INPUT' &&
-    (elem.type === 'text' || elem.type === 'password')
-  );
-};
-
+/**
+ * For IE shims
+ */
 var activeElement = null;
 var activeElementID = null;
 var activeElementValue = null;
 var activeElementValueProp = null;
 
+
+/**
+ * SECTION: handle `change` event
+ */
+var shouldUseChangeEvent = function(elem) {
+  return elem.nodeName === 'SELECT';
+};
+
+var doesChangeEventBubble = false;
+if (ExecutionEnvironment.canUseDOM) {
+  // See `handleChange` comment below
+  doesChangeEventBubble = isEventSupported('change') && (
+    !('documentMode' in document) || document.documentMode > 8
+  );
+}
+
+/**
+ * (For IE8). The `change` event does not bubble in IE8 so we add a listener
+ * when the element is focused (and remove when blurred).
+ */
+var handleChange = function(nativeEvent) {
+  var event = SyntheticEvent.getPooled(
+    eventTypes.change,
+    activeElementID,
+    nativeEvent
+  );
+  EventPropagators.accumulateTwoPhaseDispatches(event);
+
+  // If change bubbled, we'd just bind to it like all the other events
+  // and have it go through ReactEventTopLevelCallback. Since it doesn't, we
+  // manually listen for the change event and so we have to enqueue and
+  // process the abstract event manually.
+  EventPluginHub.enqueueEvents(event);
+  EventPluginHub.processEventQueue();
+};
+
+var getTargetIDForChangeEvent;
+if (doesChangeEventBubble) {
+  getTargetIDForChangeEvent = function(
+      topLevelType,
+      topLevelTarget,
+      topLevelTargetID) {
+    if (topLevelType === topLevelTypes.topChange) {
+      return topLevelTargetID;
+    }
+  };
+} else {
+  getTargetIDForChangeEvent = function(
+      topLevelType,
+      topLevelTarget,
+      topLevelTargetID) {
+    if (topLevelType === topLevelTypes.topFocus) {
+      activeElementID = topLevelTargetID;
+      topLevelTarget.attachEvent('onchange', handleChange);
+    } else if (topLevelType === topLevelTypes.topBlur) {
+      topLevelTarget.detachEvent('onchange', handleChange);
+      activeElementID = null;
+    }
+  };
+}
+
+
+/**
+ * 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
+  );
+}
+
+
+/**
+ * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
+ */
+var supportedInputTypes = {
+  'color': true,
+  'date': true,
+  'datetime': true,
+  'datetime-local': true,
+  'email': true,
+  'month': true,
+  'number': true,
+  'password': true,
+  'range': true,
+  'search': true,
+  'tel': true,
+  'text': true,
+  'time': true,
+  'url': true,
+  'week': true
+};
+
+var shouldUseInputEvent = function(elem) {
+  return (
+    (elem.nodeName === 'INPUT' && supportedInputTypes[elem.type]) ||
+    elem.nodeName === 'TEXTAREA'
+  );
+};
+
 /**
  * (For old IE.) Replacement getter/setter for the `value` property that gets
  * set on the active element.
@@ -84,7 +168,7 @@ var newValueProp =  {
  * and override the value property so that we can distinguish user events from
  * value changes in JS.
  */
-var startWatching = function(target, targetID) {
+var startWatchingForValueChange = function(target, targetID) {
   activeElement = target;
   activeElementID = targetID;
   activeElementValue = target.value;
@@ -101,7 +185,7 @@ var startWatching = function(target, targetID) {
  * (For old IE.) Removes the event listeners from the currently-tracked element,
  * if any exists.
  */
-var stopWatching = function() {
+var stopWatchingForValueChange = function() {
   if (!activeElement) {
     return;
   }
@@ -117,11 +201,11 @@ var stopWatching = function() {
 };
 
 /**
- * (For old IE.) Handles a propertychange event, sending a textChange event if
+ * (For old IE.) Handles a propertychange event, sending a `change` event if
  * the value of the active element has changed.
  */
 var handlePropertyChange = function(nativeEvent) {
-  if (nativeEvent.propertyName !== "value") {
+  if (nativeEvent.propertyName !== 'value') {
     return;
   }
   var value = nativeEvent.srcElement.value;
@@ -131,42 +215,34 @@ var handlePropertyChange = function(nativeEvent) {
   activeElementValue = value;
 
   var event = SyntheticEvent.getPooled(
-    eventTypes.textChange,
+    eventTypes.change,
     activeElementID,
     nativeEvent
   );
   EventPropagators.accumulateTwoPhaseDispatches(event);
 
-  // If propertychange bubbled, we'd just bind to it like all the other events
-  // and have it go through ReactEventTopLevelCallback. Since it doesn't, we
-  // manually listen for the propertychange event and so we have to enqueue and
-  // process the abstract event manually.
+  // See comment above in handleChange
   EventPluginHub.enqueueEvents(event);
   EventPluginHub.processEventQueue();
 };
 
 /**
- * If a textChange event should be fired, returns the target's ID.
+ * If a `change` event should be fired, returns the target's ID.
  */
-var targetIDForTextChangeEvent;
-if (isInputSupported) {
-  targetIDForTextChangeEvent = function(
+var getTargetIDForValueChangeEvent;
+if (isInputEventSupported) {
+  getTargetIDForValueChangeEvent = function(
       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...
-      if (topLevelTarget.nodeName === 'TEXTAREA') {
-        // ...unless it's a textarea, in which case we don't fire an event (so
-        // that we have consistency with our old-IE shim).
-        return;
-      }
+      // what we want so fall through here and trigger an abstract event
       return topLevelTargetID;
     }
   };
 } else {
-  targetIDForTextChangeEvent = function(
+  getTargetIDForValueChangeEvent = function(
       topLevelType,
       topLevelTarget,
       topLevelTargetID) {
@@ -181,14 +257,13 @@ if (isInputSupported) {
       // 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
-      if (hasInputCapabilities(topLevelTarget)) {
-        // stopWatching() should be a noop here but we call it just in case we
-        // missed a blur event somehow.
-        stopWatching();
-        startWatching(topLevelTarget, topLevelTargetID);
-      }
+      //
+      // 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) {
-      stopWatching();
+      stopWatchingForValueChange();
     } else if (
         topLevelType === topLevelTypes.topSelectionChange ||
         topLevelType === topLevelTypes.topKeyUp ||
@@ -211,7 +286,40 @@ if (isInputSupported) {
   };
 }
 
-var TextChangeEventPlugin = {
+
+/**
+ * SECTION: handle `click` event
+ */
+var shouldUseClickEvent = function(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')
+  );
+};
+
+var getTargetIDForClickEvent = function(
+    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 `supportedInputTypes`)
+ * - textarea
+ * - select
+ */
+var ChangeEventPlugin = {
 
   eventTypes: eventTypes,
 
@@ -228,15 +336,26 @@ var TextChangeEventPlugin = {
       topLevelTarget,
       topLevelTargetID,
       nativeEvent) {
-    var targetID = targetIDForTextChangeEvent(
-      topLevelType,
-      topLevelTarget,
-      topLevelTargetID
-    );
+
+    var getTargetIDFunc, targetID;
+    if (shouldUseChangeEvent(topLevelTarget)) {
+      getTargetIDFunc = getTargetIDForChangeEvent;
+    } else if (shouldUseInputEvent(topLevelTarget)) {
+      getTargetIDFunc = getTargetIDForValueChangeEvent;
+    } else if (shouldUseClickEvent(topLevelTarget)) {
+      getTargetIDFunc = getTargetIDForClickEvent;
+    }
+    if (getTargetIDFunc) {
+      targetID = getTargetIDFunc(
+        topLevelType,
+        topLevelTarget,
+        topLevelTargetID
+      );
+    }
 
     if (targetID) {
       var event = SyntheticEvent.getPooled(
-        eventTypes.textChange,
+        eventTypes.change,
         targetID,
         nativeEvent
       );
@@ -247,4 +366,4 @@ var TextChangeEventPlugin = {
 
 };
 
-module.exports = TextChangeEventPlugin;
+module.exports = ChangeEventPlugin;
diff --git a/src/eventPlugins/DefaultEventPluginOrder.js b/src/eventPlugins/DefaultEventPluginOrder.js
index ab7ee4448d..4374d967d4 100644
--- a/src/eventPlugins/DefaultEventPluginOrder.js
+++ b/src/eventPlugins/DefaultEventPluginOrder.js
@@ -34,7 +34,7 @@ var DefaultEventPluginOrder = [
   keyOf({SimpleEventPlugin: null}),
   keyOf({TapEventPlugin: null}),
   keyOf({EnterLeaveEventPlugin: null}),
-  keyOf({TextChangeEventPlugin: null}),
+  keyOf({ChangeEventPlugin: null}),
   keyOf({AnalyticsEventPlugin: null})
 ];
 
diff --git a/src/eventPlugins/SimpleEventPlugin.js b/src/eventPlugins/SimpleEventPlugin.js
index bca0d4604a..b11de71145 100644
--- a/src/eventPlugins/SimpleEventPlugin.js
+++ b/src/eventPlugins/SimpleEventPlugin.js
@@ -41,12 +41,6 @@ var eventTypes = {
       captured: keyOf({onBlurCapture: true})
     }
   },
-  change: {
-    phasedRegistrationNames: {
-      bubbled: keyOf({onChange: true}),
-      captured: keyOf({onChangeCapture: true})
-    }
-  },
   click: {
     phasedRegistrationNames: {
       bubbled: keyOf({onClick: true}),
@@ -209,7 +203,6 @@ var eventTypes = {
 
 var topLevelEventsToDispatchConfig = {
   topBlur:        eventTypes.blur,
-  topChange:      eventTypes.change,
   topClick:       eventTypes.click,
   topDoubleClick: eventTypes.doubleClick,
   topDOMCharacterDataModified: eventTypes.DOMCharacterDataModified,
@@ -277,7 +270,6 @@ var SimpleEventPlugin = {
     }
     var EventConstructor;
     switch(topLevelType) {
-      case topLevelTypes.topChange:
       case topLevelTypes.topInput:
       case topLevelTypes.topSubmit:
         // HTML Events

From d93761af6253aa994660eb04be9313cddc920844 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Tue, 25 Jun 2013 13:56:56 -0700
Subject: [PATCH 64/94] Enforce nodeCache validity

A node is considered valid if it

  1. has the expected ID (more of a sanity check than something that is
     ever likely to go wrong), and

  2. is contained by a currently mounted container.

When these requirements are met, we can be confident that
`ReactMount.findReactRenderedDOMNodeSlow(node.id) === node`, which is
important for cache consistency because `findReactRenderedDOMNodeSlow` is
what we fall back to when we don't find a node in the cache.

Point 2 is a subtle requirement, because it allows nodes to be valid even
if they are not currently contained by a document. Rendering into a
detached node is okay, in other words (which is something that
`document.getElementById` never properly accounted for).

Containment testing takes linear time in the depth of the DOM, which
sounds unfortunate until you realize that virtually all browsers support a
native `ancestor.contains(descendant)` method, and in practice the vast
majority of nodes are either orphaned with `.parentNode === null` or not
very deep relative to their container.
---
 src/core/ReactID.js | 103 ++++++++++++++++++++++++++++++++++++--------
 1 file changed, 85 insertions(+), 18 deletions(-)

diff --git a/src/core/ReactID.js b/src/core/ReactID.js
index f791285557..276520df9e 100644
--- a/src/core/ReactID.js
+++ b/src/core/ReactID.js
@@ -19,6 +19,7 @@
 
 "use strict";
 
+var invariant = require('invariant');
 var ReactMount = require('ReactMount');
 var ATTR_NAME = 'id';
 var nodeCache = {};
@@ -34,20 +35,34 @@ var nodeCache = {};
  * @return {string} ID of the supplied `domNode`.
  */
 function getID(node) {
-  if (node && node.getAttributeNode) {
-    var attributeNode = node.getAttributeNode(ATTR_NAME);
-    if (attributeNode) {
-      var id = attributeNode.value;
-      if (id) {
-        // Assume that any node previously cached with this ID has since
-        // become invalid and should be replaced. TODO Enforce this.
-        nodeCache[id] = node;
+  var id = internalGetID(node);
+  if (id) {
+    if (nodeCache.hasOwnProperty(id)) {
+      var cached = nodeCache[id];
+      if (cached !== node) {
+        invariant(
+          !isValid(cached, id),
+          'ReactID: Two valid but unequal nodes with the same `%s`: %s',
+          ATTR_NAME, id
+        );
 
-        return id;
+        nodeCache[id] = node;
       }
+    } else {
+      nodeCache[id] = node;
     }
   }
 
+  return id;
+}
+
+function internalGetID(node) {
+  if (node && node.getAttributeNode) {
+    var attributeNode = node.getAttributeNode(ATTR_NAME);
+    if (attributeNode) {
+      return attributeNode.value || '';
+    }
+  }
   return '';
 }
 
@@ -58,7 +73,7 @@ function getID(node) {
  * @param {string} id The value of the ID attribute.
  */
 function setID(node, id) {
-  var oldID = getID(node);
+  var oldID = internalGetID(node);
   if (oldID !== id) {
     delete nodeCache[oldID];
   }
@@ -74,18 +89,70 @@ function setID(node, id) {
  * @internal
  */
 function getNode(id) {
-  if (!nodeCache[id]) {
-    nodeCache[id] =
-      document.getElementById(id) || // TODO Quit using getElementById.
-      ReactMount.findReactRenderedDOMNodeSlow(id);
+  if (nodeCache.hasOwnProperty(id)) {
+    var node = nodeCache[id];
+    if (isValid(node, id)) {
+      return node;
+    }
   }
 
-  var node = nodeCache[id];
-  if (getID(node) === id) {
-    return node;
+  return nodeCache[id] =
+    document.getElementById(id) || // TODO Quit using getElementById.
+    ReactMount.findReactRenderedDOMNodeSlow(id);
+}
+
+/**
+ * A node is "valid" if it is contained by a currently mounted container.
+ *
+ * This means that the node does not have to be contained by a document in
+ * order to be considered valid.
+ *
+ * @param {?DOMElement} node The candidate DOM node.
+ * @param {string} id The expected ID of the node.
+ * @return {boolean} Whether the node is contained by a mounted container.
+ */
+function isValid(node, id) {
+  if (node) {
+    invariant(
+      internalGetID(node) === id,
+      'ReactID: Unexpected modification of `%s`',
+      ATTR_NAME
+    );
+
+    var container = ReactMount.findReactContainerForID(id);
+    if (container && contains(container, node)) {
+      return true;
+    }
   }
 
-  return null;
+  return false;
+}
+
+function contains(ancestor, descendant) {
+  if (ancestor.contains) {
+    // Supported natively in virtually all browsers, but not in jsdom.
+    return ancestor.contains(descendant);
+  }
+
+  if (descendant === ancestor) {
+    return true;
+  }
+
+  if (descendant.nodeType === 3) {
+    // If descendant is a text node, start from descendant.parentNode
+    // instead, so that we can assume all ancestors worth considering are
+    // element nodes with nodeType === 1.
+    descendant = descendant.parentNode;
+  }
+
+  while (descendant && descendant.nodeType === 1) {
+    if (descendant === ancestor) {
+      return true;
+    }
+    descendant = descendant.parentNode;
+  }
+
+  return false;
 }
 
 /**

From a9b024330c66736fe1b0a3426e3e4f988b26d85a Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Tue, 25 Jun 2013 13:57:06 -0700
Subject: [PATCH 65/94] Make `@typechecks` static-only

---
 src/core/ReactDOM.js                          |  2 +-
 src/core/ReactDOMIDOperations.js              |  2 +-
 src/core/ReactDOMNodeCache.js                 | 26 ++++++++++++++++++
 src/core/ReactEventEmitter.js                 |  2 +-
 src/core/ReactEventTopLevelCallback.js        |  2 +-
 src/core/ReactID.js                           |  2 +-
 src/core/ReactInstanceHandles.js              |  2 +-
 src/core/ReactNativeComponent.js              |  2 +-
 src/core/ReactReconcileTransaction.js         |  2 +-
 src/core/ReactTextComponent.js                |  2 +-
 src/dom/CSSPropertyOperations.js              |  2 +-
 src/dom/DOMProperty.js                        |  2 +-
 src/dom/DOMPropertyOperations.js              |  2 +-
 src/dom/dangerousStyleValue.js                |  2 +-
 src/dom/getDOMNodeID.js                       | 27 +++++++++++++++++++
 src/dom/getEventTarget.js                     |  2 +-
 src/environment/ReactServerRendering.js       |  2 +-
 src/event/CallbackRegistry.js                 |  2 +-
 src/event/EventPluginRegistry.js              |  2 +-
 src/event/synthetic/SyntheticEvent.js         |  2 +-
 src/event/synthetic/SyntheticFocusEvent.js    |  2 +-
 src/event/synthetic/SyntheticKeyboardEvent.js |  2 +-
 src/event/synthetic/SyntheticMouseEvent.js    |  2 +-
 src/event/synthetic/SyntheticMutationEvent.js |  2 +-
 src/event/synthetic/SyntheticTouchEvent.js    |  2 +-
 src/event/synthetic/SyntheticUIEvent.js       |  2 +-
 src/event/synthetic/SyntheticWheelEvent.js    |  2 +-
 src/eventPlugins/EnterLeaveEventPlugin.js     |  2 +-
 src/eventPlugins/TapEventPlugin.js            |  2 +-
 src/utils/joinClasses.js                      |  2 +-
 src/utils/memoizeStringOnly.js                |  2 +-
 src/utils/mergeInto.js                        |  2 +-
 32 files changed, 83 insertions(+), 30 deletions(-)
 create mode 100644 src/core/ReactDOMNodeCache.js
 create mode 100644 src/dom/getDOMNodeID.js

diff --git a/src/core/ReactDOM.js b/src/core/ReactDOM.js
index b1882b3be0..35a15eb5d3 100644
--- a/src/core/ReactDOM.js
+++ b/src/core/ReactDOM.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule ReactDOM
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/core/ReactDOMIDOperations.js b/src/core/ReactDOMIDOperations.js
index f95fc2837a..7c0de701d8 100644
--- a/src/core/ReactDOMIDOperations.js
+++ b/src/core/ReactDOMIDOperations.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule ReactDOMIDOperations
- * @typechecks
+ * @typechecks static-only
  */
 
 /*jslint evil: true */
diff --git a/src/core/ReactDOMNodeCache.js b/src/core/ReactDOMNodeCache.js
new file mode 100644
index 0000000000..4ea1bb63e9
--- /dev/null
+++ b/src/core/ReactDOMNodeCache.js
@@ -0,0 +1,26 @@
+/**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @providesModule ReactDOMNodeCache
+ * @typechecks static-only
+ */
+
+"use strict";
+
+var ReactID = require('ReactID');
+
+exports.getNodeByID = ReactID.getNode;
+exports.purgeID = ReactID.purgeID;
+exports.purgeEntireCache = ReactID.purgeEntireCache;
diff --git a/src/core/ReactEventEmitter.js b/src/core/ReactEventEmitter.js
index 65f5072bbf..aa6a81e236 100644
--- a/src/core/ReactEventEmitter.js
+++ b/src/core/ReactEventEmitter.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule ReactEventEmitter
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/core/ReactEventTopLevelCallback.js b/src/core/ReactEventTopLevelCallback.js
index 25719e812c..215d23da23 100644
--- a/src/core/ReactEventTopLevelCallback.js
+++ b/src/core/ReactEventTopLevelCallback.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule ReactEventTopLevelCallback
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/core/ReactID.js b/src/core/ReactID.js
index 276520df9e..c15dbfcec0 100644
--- a/src/core/ReactID.js
+++ b/src/core/ReactID.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule ReactID
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/core/ReactInstanceHandles.js b/src/core/ReactInstanceHandles.js
index dd8e68c219..de0b2777e2 100644
--- a/src/core/ReactInstanceHandles.js
+++ b/src/core/ReactInstanceHandles.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule ReactInstanceHandles
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/core/ReactNativeComponent.js b/src/core/ReactNativeComponent.js
index eddb27ec5f..a160adf1cf 100644
--- a/src/core/ReactNativeComponent.js
+++ b/src/core/ReactNativeComponent.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule ReactNativeComponent
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/core/ReactReconcileTransaction.js b/src/core/ReactReconcileTransaction.js
index a44214dcb8..904df5e719 100644
--- a/src/core/ReactReconcileTransaction.js
+++ b/src/core/ReactReconcileTransaction.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule ReactReconcileTransaction
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/core/ReactTextComponent.js b/src/core/ReactTextComponent.js
index 57e56bbce2..1d0af59858 100644
--- a/src/core/ReactTextComponent.js
+++ b/src/core/ReactTextComponent.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule ReactTextComponent
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/dom/CSSPropertyOperations.js b/src/dom/CSSPropertyOperations.js
index ab46485f36..e664ad432e 100644
--- a/src/dom/CSSPropertyOperations.js
+++ b/src/dom/CSSPropertyOperations.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule CSSPropertyOperations
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/dom/DOMProperty.js b/src/dom/DOMProperty.js
index 52c4fcd07e..0d763036a7 100644
--- a/src/dom/DOMProperty.js
+++ b/src/dom/DOMProperty.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule DOMProperty
- * @typechecks
+ * @typechecks static-only
  */
 
 /*jslint bitwise: true */
diff --git a/src/dom/DOMPropertyOperations.js b/src/dom/DOMPropertyOperations.js
index b582bf914c..cb5d55ad4c 100644
--- a/src/dom/DOMPropertyOperations.js
+++ b/src/dom/DOMPropertyOperations.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule DOMPropertyOperations
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/dom/dangerousStyleValue.js b/src/dom/dangerousStyleValue.js
index 9c12b12ab3..216396563e 100644
--- a/src/dom/dangerousStyleValue.js
+++ b/src/dom/dangerousStyleValue.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule dangerousStyleValue
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/dom/getDOMNodeID.js b/src/dom/getDOMNodeID.js
new file mode 100644
index 0000000000..41a921eeb2
--- /dev/null
+++ b/src/dom/getDOMNodeID.js
@@ -0,0 +1,27 @@
+/**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @providesModule getDOMNodeID
+ * @typechecks static-only
+ */
+
+"use strict";
+
+var ReactID = require('ReactID');
+
+function getDOMNodeID(domNode) {
+  return ReactID.getID(domNode);
+}
+module.exports = getDOMNodeID;
diff --git a/src/dom/getEventTarget.js b/src/dom/getEventTarget.js
index 7cb4ce3eb7..e1b10aebc4 100644
--- a/src/dom/getEventTarget.js
+++ b/src/dom/getEventTarget.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule getEventTarget
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/environment/ReactServerRendering.js b/src/environment/ReactServerRendering.js
index b7c43d13ec..0a0b598927 100644
--- a/src/environment/ReactServerRendering.js
+++ b/src/environment/ReactServerRendering.js
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * @typechecks
+ * @typechecks static-only
  * @providesModule ReactServerRendering
  */
 "use strict";
diff --git a/src/event/CallbackRegistry.js b/src/event/CallbackRegistry.js
index a0c2b5aca5..e0cf9a5c82 100644
--- a/src/event/CallbackRegistry.js
+++ b/src/event/CallbackRegistry.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule CallbackRegistry
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/event/EventPluginRegistry.js b/src/event/EventPluginRegistry.js
index e9302eb495..14a2fcb024 100644
--- a/src/event/EventPluginRegistry.js
+++ b/src/event/EventPluginRegistry.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule EventPluginRegistry
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/event/synthetic/SyntheticEvent.js b/src/event/synthetic/SyntheticEvent.js
index 366da3cbc6..2370528851 100644
--- a/src/event/synthetic/SyntheticEvent.js
+++ b/src/event/synthetic/SyntheticEvent.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule SyntheticEvent
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/event/synthetic/SyntheticFocusEvent.js b/src/event/synthetic/SyntheticFocusEvent.js
index a90ba3f79a..cf17be6bf0 100644
--- a/src/event/synthetic/SyntheticFocusEvent.js
+++ b/src/event/synthetic/SyntheticFocusEvent.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule SyntheticFocusEvent
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/event/synthetic/SyntheticKeyboardEvent.js b/src/event/synthetic/SyntheticKeyboardEvent.js
index 6e6b078282..c7c64e21bb 100644
--- a/src/event/synthetic/SyntheticKeyboardEvent.js
+++ b/src/event/synthetic/SyntheticKeyboardEvent.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule SyntheticKeyboardEvent
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/event/synthetic/SyntheticMouseEvent.js b/src/event/synthetic/SyntheticMouseEvent.js
index 5e5dd8ded8..8dde7e1045 100644
--- a/src/event/synthetic/SyntheticMouseEvent.js
+++ b/src/event/synthetic/SyntheticMouseEvent.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule SyntheticMouseEvent
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/event/synthetic/SyntheticMutationEvent.js b/src/event/synthetic/SyntheticMutationEvent.js
index 55ae1baa35..44bbc0d3c7 100644
--- a/src/event/synthetic/SyntheticMutationEvent.js
+++ b/src/event/synthetic/SyntheticMutationEvent.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule SyntheticMutationEvent
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/event/synthetic/SyntheticTouchEvent.js b/src/event/synthetic/SyntheticTouchEvent.js
index 304e592608..3c3348bfbf 100644
--- a/src/event/synthetic/SyntheticTouchEvent.js
+++ b/src/event/synthetic/SyntheticTouchEvent.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule SyntheticTouchEvent
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/event/synthetic/SyntheticUIEvent.js b/src/event/synthetic/SyntheticUIEvent.js
index 4e2b0d5964..5d95ea1417 100644
--- a/src/event/synthetic/SyntheticUIEvent.js
+++ b/src/event/synthetic/SyntheticUIEvent.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule SyntheticUIEvent
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/event/synthetic/SyntheticWheelEvent.js b/src/event/synthetic/SyntheticWheelEvent.js
index bab71dd4ba..5d2320f9ae 100644
--- a/src/event/synthetic/SyntheticWheelEvent.js
+++ b/src/event/synthetic/SyntheticWheelEvent.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule SyntheticWheelEvent
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/eventPlugins/EnterLeaveEventPlugin.js b/src/eventPlugins/EnterLeaveEventPlugin.js
index d01e032b99..f7a385ba18 100644
--- a/src/eventPlugins/EnterLeaveEventPlugin.js
+++ b/src/eventPlugins/EnterLeaveEventPlugin.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule EnterLeaveEventPlugin
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/eventPlugins/TapEventPlugin.js b/src/eventPlugins/TapEventPlugin.js
index 75409ab4b3..c748da79e7 100644
--- a/src/eventPlugins/TapEventPlugin.js
+++ b/src/eventPlugins/TapEventPlugin.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule TapEventPlugin
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/utils/joinClasses.js b/src/utils/joinClasses.js
index af367123d8..d65bee6dc4 100644
--- a/src/utils/joinClasses.js
+++ b/src/utils/joinClasses.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule joinClasses
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/utils/memoizeStringOnly.js b/src/utils/memoizeStringOnly.js
index a11d026a23..3a8971358d 100644
--- a/src/utils/memoizeStringOnly.js
+++ b/src/utils/memoizeStringOnly.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule memoizeStringOnly
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";
diff --git a/src/utils/mergeInto.js b/src/utils/mergeInto.js
index ac8ea868a7..376571357f 100644
--- a/src/utils/mergeInto.js
+++ b/src/utils/mergeInto.js
@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @providesModule mergeInto
- * @typechecks
+ * @typechecks static-only
  */
 
 "use strict";

From 59212a538ed838d09e5a5d870f60e1cd66c2302c Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Tue, 25 Jun 2013 14:15:20 -0700
Subject: [PATCH 66/94] Remove deleted files again

These accidentally got re-added in a rebase
---
 src/core/ReactDOMNodeCache.js | 26 --------------------------
 src/dom/getDOMNodeID.js       | 27 ---------------------------
 2 files changed, 53 deletions(-)
 delete mode 100644 src/core/ReactDOMNodeCache.js
 delete mode 100644 src/dom/getDOMNodeID.js

diff --git a/src/core/ReactDOMNodeCache.js b/src/core/ReactDOMNodeCache.js
deleted file mode 100644
index 4ea1bb63e9..0000000000
--- a/src/core/ReactDOMNodeCache.js
+++ /dev/null
@@ -1,26 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactDOMNodeCache
- * @typechecks static-only
- */
-
-"use strict";
-
-var ReactID = require('ReactID');
-
-exports.getNodeByID = ReactID.getNode;
-exports.purgeID = ReactID.purgeID;
-exports.purgeEntireCache = ReactID.purgeEntireCache;
diff --git a/src/dom/getDOMNodeID.js b/src/dom/getDOMNodeID.js
deleted file mode 100644
index 41a921eeb2..0000000000
--- a/src/dom/getDOMNodeID.js
+++ /dev/null
@@ -1,27 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule getDOMNodeID
- * @typechecks static-only
- */
-
-"use strict";
-
-var ReactID = require('ReactID');
-
-function getDOMNodeID(domNode) {
-  return ReactID.getID(domNode);
-}
-module.exports = getDOMNodeID;

From 43930455de2ce9d6a9d8eb20cbb3ac4be828908f Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Wed, 26 Jun 2013 11:20:26 -0700
Subject: [PATCH 67/94] Cache Default Props

The `getDefaultProps` return value should not be dependent on any external data (including `this.props` and `this.state`), so the return value should be consistent everytime we call it.

This caches the return value so we do not do work and allocate memory unnecessarily.
---
 src/core/ReactCompositeComponent.js | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/core/ReactCompositeComponent.js b/src/core/ReactCompositeComponent.js
index df9e5bbd78..6c4fed8fd7 100644
--- a/src/core/ReactCompositeComponent.js
+++ b/src/core/ReactCompositeComponent.js
@@ -105,9 +105,8 @@ var ReactCompositeComponentInterface = {
   // ==== Definition methods ====
 
   /**
-   * Invoked when the component is mounted and whenever new props are received.
-   * Values in the returned mapping will be set on `this.props` if that prop is
-   * not specified (i.e. using an `in` check).
+   * Invoked when the component is mounted. Values in the mapping will be set on
+   * `this.props` if that prop is not specified (i.e. using an `in` check).
    *
    * This method is invoked before `getInitialState` and therefore cannot rely
    * on `this.state` or use `this.setState`.
@@ -504,6 +503,8 @@ var ReactCompositeComponentMixin = {
   mountComponent: function(rootID, transaction) {
     ReactComponent.Mixin.mountComponent.call(this, rootID, transaction);
     this._compositeLifeCycleState = CompositeLifeCycle.MOUNTING;
+
+    this._defaultProps = this.getDefaultProps ? this.getDefaultProps() : null;
     this._processProps(this.props);
 
     if (this.__reactAutoBindMap) {
@@ -549,6 +550,8 @@ var ReactCompositeComponentMixin = {
     }
     this._compositeLifeCycleState = null;
 
+    this._defaultProps = null;
+
     ReactComponent.Mixin.unmountComponent.call(this);
     this._renderedComponent.unmountComponent();
     this._renderedComponent = null;
@@ -651,12 +654,10 @@ var ReactCompositeComponentMixin = {
    */
   _processProps: function(props) {
     var propName;
-    if (this.getDefaultProps) {
-      var defaultProps = this.getDefaultProps();
-      for (propName in defaultProps) {
-        if (!(propName in props)) {
-          props[propName] = defaultProps[propName];
-        }
+    var defaultProps = this._defaultProps;
+    for (propName in defaultProps) {
+      if (!(propName in props)) {
+        props[propName] = defaultProps[propName];
       }
     }
     var propDeclarations = this.constructor.propDeclarations;

From cf926338bf64da66ccf44e1ad8f0cbf8cf83a924 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Wed, 26 Jun 2013 11:20:31 -0700
Subject: [PATCH 68/94] Fix `onChange` for File Input

Makes sure that `onChange` fires for file inputs.
---
 src/eventPlugins/ChangeEventPlugin.js | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/eventPlugins/ChangeEventPlugin.js b/src/eventPlugins/ChangeEventPlugin.js
index 8dca1bb05c..358547f1f0 100644
--- a/src/eventPlugins/ChangeEventPlugin.js
+++ b/src/eventPlugins/ChangeEventPlugin.js
@@ -51,7 +51,10 @@ var activeElementValueProp = null;
  * SECTION: handle `change` event
  */
 var shouldUseChangeEvent = function(elem) {
-  return elem.nodeName === 'SELECT';
+  return (
+    elem.nodeName === 'SELECT' ||
+    (elem.nodeName === 'INPUT' && elem.type === 'file')
+  );
 };
 
 var doesChangeEventBubble = false;

From 5a85c5e53543b4a4c45e59009eaaa8fe14d8d500 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Wed, 26 Jun 2013 11:20:36 -0700
Subject: [PATCH 69/94] Don't pass a null context to Function.prototype.call.

This prevents PhantomJS tests from hanging in the open-source React repo.

Until the advent of `"use strict"`, passing `null` as the context object
to `.call` or `.apply` resulted in `this` taking on the value of the
global object inside the invoked function.

Technically the `"use strict"` directive is supposed to make it possible
that `this === null`, but strict mode is not respected by all browsers,
including (unfortunately) PhantomJS.

Since these `expect`-ations are just testing binding behavior, let's not
make them also test strict mode `this` handling.
---
 src/core/__tests__/ReactCompositeComponent-test.js | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/core/__tests__/ReactCompositeComponent-test.js b/src/core/__tests__/ReactCompositeComponent-test.js
index c9aad6498a..abbd7cf17f 100644
--- a/src/core/__tests__/ReactCompositeComponent-test.js
+++ b/src/core/__tests__/ReactCompositeComponent-test.js
@@ -207,9 +207,10 @@ describe('ReactCompositeComponent', function() {
     var autoBound = instance.methodAutoBound;
     var explicitlyNotBound = instance.methodExplicitlyNotBound;
 
-    expect(explicitlyBound.call(null)).toBe(instance);
-    expect(autoBound.call(null)).toBe(instance);
-    expect(explicitlyNotBound.call(null)).toBe(null);
+    var context = {};
+    expect(explicitlyBound.call(context)).toBe(instance);
+    expect(autoBound.call(context)).toBe(instance);
+    expect(explicitlyNotBound.call(context)).toBe(context);
 
     expect(explicitlyBound.call(instance)).toBe(instance);
     expect(autoBound.call(instance)).toBe(instance);

From 703c8251960d1ccc736cb6eca5c7254417fc9b44 Mon Sep 17 00:00:00 2001
From: Mathieu M-Gosselin <mathieumg@gmail.com>
Date: Wed, 26 Jun 2013 16:24:51 -0400
Subject: [PATCH 70/94] Changed JSON data in the tutorial to use double quotes
 for strings.

---
 docs/docs/tutorial.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/docs/tutorial.md b/docs/docs/tutorial.md
index bc5b02c56c..021ff5057a 100644
--- a/docs/docs/tutorial.md
+++ b/docs/docs/tutorial.md
@@ -262,8 +262,8 @@ So far we've been inserting the comments directly in the source code. Instead, l
 ```javascript
 // tutorial8.js
 var data = [
-  {author: 'Pete Hunt', text: 'This is one comment'},
-  {author: 'Jordan Walke', text: 'This is *another* comment'}
+  {author: "Pete Hunt", text: "This is one comment"},
+  {author: "Jordan Walke", text: "This is *another* comment"}
 ];
 ```
 
@@ -357,8 +357,8 @@ When the component is first created, we want to GET some JSON from the server an
 ```javascript
 // tutorial13.json
 [
-  {'author': 'Pete Hunt', 'text': 'This is one comment'},
-  {'author': 'Jordan Walke', 'text': 'This is *another* comment'}
+  {"author": "Pete Hunt", "text": "This is one comment"},
+  {"author": "Jordan Walke", "text": "This is *another* comment"}
 ]
 ```
 

From 9ceaff73183837387835f9e96c80e58fc4aea34c Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Wed, 26 Jun 2013 14:29:31 -0700
Subject: [PATCH 71/94] Refactor of ChangeEventPlugin

some refactoring and also handle if `blur` doesn't fire on the form
input in IE8 (by always cleaning up on focus). per discussions with
@balpert
---
 src/eventPlugins/ChangeEventPlugin.js | 251 ++++++++++++++------------
 1 file changed, 131 insertions(+), 120 deletions(-)

diff --git a/src/eventPlugins/ChangeEventPlugin.js b/src/eventPlugins/ChangeEventPlugin.js
index 358547f1f0..b3338fdb09 100644
--- a/src/eventPlugins/ChangeEventPlugin.js
+++ b/src/eventPlugins/ChangeEventPlugin.js
@@ -50,12 +50,12 @@ var activeElementValueProp = null;
 /**
  * SECTION: handle `change` event
  */
-var shouldUseChangeEvent = function(elem) {
+function shouldUseChangeEvent(elem) {
   return (
     elem.nodeName === 'SELECT' ||
     (elem.nodeName === 'INPUT' && elem.type === 'file')
   );
-};
+}
 
 var doesChangeEventBubble = false;
 if (ExecutionEnvironment.canUseDOM) {
@@ -65,11 +65,7 @@ if (ExecutionEnvironment.canUseDOM) {
   );
 }
 
-/**
- * (For IE8). The `change` event does not bubble in IE8 so we add a listener
- * when the element is focused (and remove when blurred).
- */
-var handleChange = function(nativeEvent) {
+function manualDispatchChangeEvent(nativeEvent) {
   var event = SyntheticEvent.getPooled(
     eventTypes.change,
     activeElementID,
@@ -83,31 +79,43 @@ var handleChange = function(nativeEvent) {
   // process the abstract event manually.
   EventPluginHub.enqueueEvents(event);
   EventPluginHub.processEventQueue();
-};
+}
 
-var getTargetIDForChangeEvent;
-if (doesChangeEventBubble) {
-  getTargetIDForChangeEvent = function(
-      topLevelType,
-      topLevelTarget,
-      topLevelTargetID) {
-    if (topLevelType === topLevelTypes.topChange) {
-      return topLevelTargetID;
-    }
-  };
-} else {
-  getTargetIDForChangeEvent = function(
-      topLevelType,
-      topLevelTarget,
-      topLevelTargetID) {
-    if (topLevelType === topLevelTypes.topFocus) {
-      activeElementID = topLevelTargetID;
-      topLevelTarget.attachEvent('onchange', handleChange);
-    } else if (topLevelType === topLevelTypes.topBlur) {
-      topLevelTarget.detachEvent('onchange', handleChange);
-      activeElementID = null;
-    }
-  };
+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();
+  }
 }
 
 
@@ -145,12 +153,12 @@ var supportedInputTypes = {
   'week': true
 };
 
-var shouldUseInputEvent = function(elem) {
+function shouldUseInputEvent(elem) {
   return (
     (elem.nodeName === 'INPUT' && supportedInputTypes[elem.type]) ||
     elem.nodeName === 'TEXTAREA'
   );
-};
+}
 
 /**
  * (For old IE.) Replacement getter/setter for the `value` property that gets
@@ -171,7 +179,7 @@ var newValueProp =  {
  * and override the value property so that we can distinguish user events from
  * value changes in JS.
  */
-var startWatchingForValueChange = function(target, targetID) {
+function startWatchingForValueChange(target, targetID) {
   activeElement = target;
   activeElementID = targetID;
   activeElementValue = target.value;
@@ -182,13 +190,13 @@ var startWatchingForValueChange = function(target, targetID) {
 
   Object.defineProperty(activeElement, 'value', newValueProp);
   activeElement.attachEvent('onpropertychange', handlePropertyChange);
-};
+}
 
 /**
  * (For old IE.) Removes the event listeners from the currently-tracked element,
  * if any exists.
  */
-var stopWatchingForValueChange = function() {
+function stopWatchingForValueChange() {
   if (!activeElement) {
     return;
   }
@@ -201,13 +209,13 @@ var stopWatchingForValueChange = function() {
   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.
  */
-var handlePropertyChange = function(nativeEvent) {
+function handlePropertyChange(nativeEvent) {
   if (nativeEvent.propertyName !== 'value') {
     return;
   }
@@ -217,83 +225,72 @@ var handlePropertyChange = function(nativeEvent) {
   }
   activeElementValue = value;
 
-  var event = SyntheticEvent.getPooled(
-    eventTypes.change,
-    activeElementID,
-    nativeEvent
-  );
-  EventPropagators.accumulateTwoPhaseDispatches(event);
-
-  // See comment above in handleChange
-  EventPluginHub.enqueueEvents(event);
-  EventPluginHub.processEventQueue();
-};
+  manualDispatchChangeEvent(nativeEvent);
+}
 
 /**
  * If a `change` event should be fired, returns the target's ID.
  */
-var getTargetIDForValueChangeEvent;
-if (isInputEventSupported) {
-  getTargetIDForValueChangeEvent = function(
-      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;
+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();
+  } else 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;
     }
-  };
-} else {
-  getTargetIDForValueChangeEvent = function(
-      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();
-    } else 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
  */
-var shouldUseClickEvent = function(elem) {
+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.
@@ -301,16 +298,16 @@ var shouldUseClickEvent = function(elem) {
     elem.nodeName === 'INPUT' &&
     (elem.type === 'checkbox' || elem.type === 'radio')
   );
-};
+}
 
-var getTargetIDForClickEvent = function(
+function getTargetIDForClickEvent(
     topLevelType,
     topLevelTarget,
     topLevelTargetID) {
   if (topLevelType === topLevelTypes.topClick) {
     return topLevelTargetID;
   }
-};
+}
 
 /**
  * This plugin creates an `onChange` event that normalizes change events
@@ -340,30 +337,44 @@ var ChangeEventPlugin = {
       topLevelTargetID,
       nativeEvent) {
 
-    var getTargetIDFunc, targetID;
+    var getTargetIDFunc, handleEventFunc;
     if (shouldUseChangeEvent(topLevelTarget)) {
-      getTargetIDFunc = getTargetIDForChangeEvent;
+      if (doesChangeEventBubble) {
+        getTargetIDFunc = getTargetIDForChangeEvent;
+      } else {
+        handleEventFunc = handleEventsForChangeEventIE8;
+      }
     } else if (shouldUseInputEvent(topLevelTarget)) {
-      getTargetIDFunc = getTargetIDForValueChangeEvent;
+      if (isInputEventSupported) {
+        getTargetIDFunc = getTargetIDForInputEvent;
+      } else {
+        handleEventFunc = handleEventsForInputEventIE;
+      }
     } else if (shouldUseClickEvent(topLevelTarget)) {
       getTargetIDFunc = getTargetIDForClickEvent;
     }
+
     if (getTargetIDFunc) {
-      targetID = getTargetIDFunc(
+      var targetID = getTargetIDFunc(
         topLevelType,
         topLevelTarget,
         topLevelTargetID
       );
-    }
-
-    if (targetID) {
-      var event = SyntheticEvent.getPooled(
-        eventTypes.change,
-        targetID,
-        nativeEvent
+      if (targetID) {
+        var event = SyntheticEvent.getPooled(
+          eventTypes.change,
+          targetID,
+          nativeEvent
+        );
+        EventPropagators.accumulateTwoPhaseDispatches(event);
+        return event;
+      }
+    } else if (handleEventFunc) {
+      handleEventFunc(
+        topLevelType,
+        topLevelTarget,
+        topLevelTargetID
       );
-      EventPropagators.accumulateTwoPhaseDispatches(event);
-      return event;
     }
   }
 

From 67cf44e7c18e068e3f39462b7ac7149eee58d3e5 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Wed, 26 Jun 2013 14:29:34 -0700
Subject: [PATCH 72/94] Change ReactID.ATTR_NAME to "data-reactid"

This final change is what we've all been waiting for.

Note that it no longer makes sense to use `document.getElementById` in
`getNode`, because that only ever worked with "id" attributes.
---
 src/core/ReactID.js    | 3 +--
 src/core/ReactMount.js | 7 +++----
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/core/ReactID.js b/src/core/ReactID.js
index c15dbfcec0..4be8bdca25 100644
--- a/src/core/ReactID.js
+++ b/src/core/ReactID.js
@@ -21,7 +21,7 @@
 
 var invariant = require('invariant');
 var ReactMount = require('ReactMount');
-var ATTR_NAME = 'id';
+var ATTR_NAME = 'data-reactid';
 var nodeCache = {};
 
 /**
@@ -97,7 +97,6 @@ function getNode(id) {
   }
 
   return nodeCache[id] =
-    document.getElementById(id) || // TODO Quit using getElementById.
     ReactMount.findReactRenderedDOMNodeSlow(id);
 }
 
diff --git a/src/core/ReactMount.js b/src/core/ReactMount.js
index 5f26d31429..56c5c54782 100644
--- a/src/core/ReactMount.js
+++ b/src/core/ReactMount.js
@@ -55,10 +55,9 @@ function getReactRootID(container) {
  *
  *   ReactMount.renderComponent(component, $('container'));
  *
- *   TODO Update this comment when ReactID.ATTR_NAME changes.
- *   <div id="container">         <-- Supplied `container`.
- *     <div id=".reactRoot[3]">   <-- Rendered reactRoot of React component.
- *       // ...
+ *   <div id="container">                   <-- Supplied `container`.
+ *     <div data-reactid=".reactRoot[3]">   <-- Rendered reactRoot of React
+ *       // ...                                 component.
  *     </div>
  *   </div>
  *

From f7e49f3b25f7c3580ed4f4c94eb1395acfb401d7 Mon Sep 17 00:00:00 2001
From: petehunt <floydophone@gmail.com>
Date: Thu, 27 Jun 2013 13:09:29 -0700
Subject: [PATCH 73/94] Recommend Node v0.10.0 due to
 https://github.com/isaacs/npm/issues/2907

---
 package.json | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/package.json b/package.json
index 7b59fa79f8..f46641c431 100644
--- a/package.json
+++ b/package.json
@@ -58,5 +58,8 @@
     "tmp": "~0.0.18",
     "grunt-contrib-compress": "~0.5.1"
   },
+  "engines": {
+    "node": ">=0.10.0"
+  },
   "preferGlobal": true
 }

From b4f096364f6a2d2a45bb3d220e507a791fd2d9dd Mon Sep 17 00:00:00 2001
From: Vjeux <vjeuxx@gmail.com>
Date: Wed, 26 Jun 2013 19:03:07 +0200
Subject: [PATCH 74/94] Community Roundup #3

---
 docs/_posts/2013-06-27-community-roundup-3.md |  91 ++++++++++++++++++
 docs/img/blog/propeller-logo.png              | Bin 0 -> 3170 bytes
 2 files changed, 91 insertions(+)
 create mode 100644 docs/_posts/2013-06-27-community-roundup-3.md
 create mode 100644 docs/img/blog/propeller-logo.png

diff --git a/docs/_posts/2013-06-27-community-roundup-3.md b/docs/_posts/2013-06-27-community-roundup-3.md
new file mode 100644
index 0000000000..021366c891
--- /dev/null
+++ b/docs/_posts/2013-06-27-community-roundup-3.md
@@ -0,0 +1,91 @@
+---
+title: "Community Round-up #3"
+layout: post
+author: Vjeux
+---
+
+The highlight of this week is that an interaction-heavy app has been ported to React. React components are solving issues they had with nested views.
+
+## Moving From Backbone To React
+
+[Clay Allsopp](http://twitter.com/clayallsopp) successfuly ported [Propeller](http://usepropeller.com/blog/posts/from-backbone-to-react/), a fairly big, interaction-heavy JavaScript app, to React.
+
+> [<img style="float: right; margin: 0 0 10px 10px;" src="/react/img/blog/propeller-logo.png" />](http://usepropeller.com/blog/posts/from-backbone-to-react/)Subviews involve a lot of easy-to-forget boilerplate that Backbone (by design) doesn't automate. Libraries like Backbone.Marionette offer more abstractions to make view nesting easier, but they're all limited by the fact that Backbone delegates how and went view-document attachment occurs to the application code.
+>
+> React, on the other hand, manages the DOM and only exposes real nodes at select points in its API. The "elements" you code in React are actually objects which wrap DOM nodes, not the actual objects which get inserted into the DOM. Internally, React converts those abstractions into actual DOMElements and fills out the document accordingly. [...]
+>
+> We moved about 20 different Backbone view classes to React over the past few weeks, including the live-preview pane that you see in our little iOS demo. Most importantly, it's allowed us to put energy into making each component work great on its own, instead of spending extra cycles to ensure they function in unison. For that reason, we think React is a more scalable way to build view-intensive apps than Backbone alone, and it doesn't require you to drop-everything-and-refactor like a move to Ember or Angular would demand.
+>
+> [Read the full post...](http://usepropeller.com/blog/posts/from-backbone-to-react/)
+
+## Grunt Task for JSX
+
+[Eric Clemmons](http://ericclemmons.github.io/) wrote a task for [Grunt](http://gruntjs.com/) that applies the JSX transformation to your Javascript files. It also works with [Browserify](http://browserify.org/) if you want all your files to be concatenated and minified together.
+
+> Grunt task for compiling Facebook React's .jsx templates into .js
+>
+> ```javascript
+grunt.initConfig({
+  react: {
+    app: {
+      options: { extension: 'js' },
+      files: { 'path/to/output/dir': 'path/to/jsx/templates/dir' }
+```
+>
+> It also works great with `grunt-browserify`!
+>
+> ```javascript
+browserify: {
+  options: {
+    transform: [ require('grunt-react').browserify ]
+  },
+  app: {
+    src: 'path/to/source/main.js',
+    dest: 'path/to/target/output.js'
+```
+>
+> [Check out the project ...](https://github.com/ericclemmons/grunt-react)
+
+## Backbone/Handlebars Nested Views
+
+[Joel Burget](http://joelburget.com/) wrote a blog post talking about the way we would write React-like components in Backbone and Handlebars.
+
+> The problem here is that we're trying to maniplate a tree, but there's a textual layer we have to go through. Our views are represented as a tree - the subviews are children of CommentCollectionView - and they end up as part of a tree in the DOM. But there's a Handlebars layer in the middle (which deals in flat strings), so the hierarchy must be destructed and rebuilt when we render.
+>
+> What does it take to render a collection view? In the Backbone/Handlebars view of the world you have to render the template (with stubs), render each subview which replaces a stub, and keep a reference to each subview (or anything within the view that could change in the future).
+>
+> So while our view is conceptually hierarchical, due to the fact that it has to go through a flat textual representation, we need to do a lot of extra work to reassemble that structure after rendering.
+>
+> [Read the full post...](http://joelburget.com/react/)
+
+## JSRomandie Meetup
+
+[Renault John Lecoultre](https://twitter.com/renajohn/) did a React introduction talk at a JS meetup called [JS Romandie](https://twitter.com/jsromandie) last week.
+
+<script async class="speakerdeck-embed" data-id="888a9d50c01b01300df36658d0894ac1" data-ratio="1.33333333333333" src="//speakerdeck.com/assets/embed.js"></script>
+
+## CoffeeScript integration
+
+[Vjeux](http://blog.vjeux.com/) used the fact that JSX is just a syntactic sugar on-top of regular JS to rewrite the React front-page examples in CoffeeScript.
+
+> Multiple people asked what's the story about JSX and CoffeeScript. There is no JSX pre-processor for CoffeeScript and I'm not aware of anyone working on it. Fortunately, CoffeeScript is pretty expressive and we can play around the syntax to come up with something that is usable.
+>
+> ```javascript
+{div, h3, textarea} = React.DOM
+(div {className: 'MarkdownEditor'}, [
+  (h3 {}, 'Input'),
+  (textarea {onKeyUp: @handleKeyUp, ref: 'textarea'},
+    @state.value
+  )
+])
+```
+>
+> [Read the full post...](http://blog.vjeux.com/2013/javascript/react-coffeescript.html)
+
+## Tutorial in Plain Javascript
+
+We've seen a lot of people comparing React with various frameworks. [Ricardo Tomasi](http://ricardo.cc/) decided to re-implement the tutorial without any framework, just plain Javascript.
+
+> Facebook & Instagram launched the React framework and an accompanying tutorial. Developer Vlad Yazhbin decided to rewrite that using AngularJS. The end result is pretty neat, but if you're like me you will not actually appreciate the HTML speaking for itself and doing all the hard work. So let's see what that looks like in plain javascript.
+>
+> [Read the full post...](http://ricardo.cc/2013/06/07/react-tutorial-rewritten-in-plain-javascript.html)
diff --git a/docs/img/blog/propeller-logo.png b/docs/img/blog/propeller-logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..1573d715b292ef50cc11bfdeab4bf4753ba0e8e8
GIT binary patch
literal 3170
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

literal 0
HcmV?d00001


From 418c1fc42797fb36eb05f1b4b2090a5352f2ea58 Mon Sep 17 00:00:00 2001
From: Christopher Chedeau <vjeuxx@gmail.com>
Date: Sun, 23 Jun 2013 22:01:28 -0600
Subject: [PATCH 75/94] Add @jsx common parser issues in the docs

Update getting-started.md
---
 docs/docs/getting-started.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/docs/docs/getting-started.md b/docs/docs/getting-started.md
index 5b732c032a..1e62818ee9 100644
--- a/docs/docs/getting-started.md
+++ b/docs/docs/getting-started.md
@@ -88,6 +88,10 @@ React.renderComponent(
 );
 ```
 
+> Note:
+>
+> The comment parser is very strict right now, in order for it to pick up the `@jsx` modifier, two conditions are required. The `@jsx` comment block must be the first comment on the file. The comment must start with `/**` (`/*` and `//` will not work). If the parser can't find the `@jsx` comment, it will output the file without transforming it.
+
 Update your HTML file as below:
 
 ```html{6,10}

From c032743b932267d5301925d60ab172430e5b6818 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Paul=20O=E2=80=99Shannessy?= <paul@oshannessy.com>
Date: Thu, 27 Jun 2013 13:30:09 -0700
Subject: [PATCH 76/94] Bump version to 0.4.0a

This should have happened a while ago, but better late than never.
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index f46641c431..4cbbd6b794 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-tools",
-  "version": "0.3.2",
+  "version": "0.4.0a",
   "keywords": [
     "react",
     "jsx",

From dbd9d99bcd01849b737f608a8862c4300cbae217 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Thu, 27 Jun 2013 16:30:03 -0700
Subject: [PATCH 77/94] Fix `findComponentRoot` w/ Unidentified Nodes

The current `ReactInstanceHandles` has a bug where `findComponentRoot` barfs if it comes across a node that was not identified by React (via `ReactID`). This fixes that.

This was always a bug, but it became more apparent once we switched to `data-reactid` because arbitrary `document.createElement`'d nodes are much more likely to have an `id` than they are to have a `data-reactid`.
---
 src/core/ReactInstanceHandles.js              |  6 +++---
 .../__tests__/ReactInstanceHandles-test.js    | 19 +++++++++++++++++++
 2 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/src/core/ReactInstanceHandles.js b/src/core/ReactInstanceHandles.js
index de0b2777e2..af508207e3 100644
--- a/src/core/ReactInstanceHandles.js
+++ b/src/core/ReactInstanceHandles.js
@@ -286,10 +286,10 @@ var ReactInstanceHandles = {
   findComponentRoot: function(ancestorNode, id) {
     var child = ancestorNode.firstChild;
     while (child) {
-      var childId = ReactID.getID(child);
-      if (id === childId) {
+      var childID = ReactID.getID(child);
+      if (id === childID) {
         return child;
-      } else if (isAncestorIDOf(childId, id)) {
+      } else if (childID && isAncestorIDOf(childID, id)) {
         return ReactInstanceHandles.findComponentRoot(child, id);
       }
       child = child.nextSibling;
diff --git a/src/core/__tests__/ReactInstanceHandles-test.js b/src/core/__tests__/ReactInstanceHandles-test.js
index 34531223fa..4daef67300 100644
--- a/src/core/__tests__/ReactInstanceHandles-test.js
+++ b/src/core/__tests__/ReactInstanceHandles-test.js
@@ -102,6 +102,25 @@ describe('ReactInstanceHandles', function() {
         )
       ).toBe(childNodeB);
     });
+
+    it('should work around unidentified nodes', function() {
+      var parentNode = document.createElement('div');
+      var childNodeA = document.createElement('div');
+      var childNodeB = document.createElement('div');
+      parentNode.appendChild(childNodeA);
+      parentNode.appendChild(childNodeB);
+
+      ReactID.setID(parentNode, '.react[0]');
+      // No ID on `childNodeA`.
+      ReactID.setID(childNodeB, '.react[0].0:1');
+
+      expect(
+        ReactInstanceHandles.findComponentRoot(
+          parentNode,
+          ReactID.getID(childNodeB)
+        )
+      ).toBe(childNodeB);
+    });
   });
 
   describe('getReactRootIDFromNodeID', function() {

From d4c7991aee61a7cd2561d74bd86da12042ff34c7 Mon Sep 17 00:00:00 2001
From: Vjeux <vjeuxx@gmail.com>
Date: Fri, 28 Jun 2013 18:35:52 +0200
Subject: [PATCH 78/94] Add link roundup

---
 docs/_posts/2013-06-27-community-roundup-3.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/_posts/2013-06-27-community-roundup-3.md b/docs/_posts/2013-06-27-community-roundup-3.md
index 021366c891..50fed07978 100644
--- a/docs/_posts/2013-06-27-community-roundup-3.md
+++ b/docs/_posts/2013-06-27-community-roundup-3.md
@@ -60,7 +60,7 @@ browserify: {
 
 ## JSRomandie Meetup
 
-[Renault John Lecoultre](https://twitter.com/renajohn/) did a React introduction talk at a JS meetup called [JS Romandie](https://twitter.com/jsromandie) last week.
+[Renault John Lecoultre](https://twitter.com/renajohn/) from [BugBuster](http://www.bugbuster.com) did a React introduction talk at a JS meetup called [JS Romandie](https://twitter.com/jsromandie) last week.
 
 <script async class="speakerdeck-embed" data-id="888a9d50c01b01300df36658d0894ac1" data-ratio="1.33333333333333" src="//speakerdeck.com/assets/embed.js"></script>
 

From e9980412296b6469f39605f48ea527776d7ac718 Mon Sep 17 00:00:00 2001
From: Ben Alpert <spicyjalapeno@gmail.com>
Date: Sat, 22 Jun 2013 01:18:09 -0700
Subject: [PATCH 79/94] Remove content property

Fixes #119.
---
 src/core/ReactDOMIDOperations.js              |  1 -
 src/core/ReactNativeComponent.js              | 33 +++++-------------
 .../__tests__/ReactDOMIDOperations-test.js    |  4 +--
 .../__tests__/ReactMultiChildText-test.js     | 34 ++++---------------
 .../__tests__/ReactNativeComponent-test.js    | 18 ++--------
 5 files changed, 19 insertions(+), 71 deletions(-)

diff --git a/src/core/ReactDOMIDOperations.js b/src/core/ReactDOMIDOperations.js
index f95fc2837a..a7b9f2b42f 100644
--- a/src/core/ReactDOMIDOperations.js
+++ b/src/core/ReactDOMIDOperations.js
@@ -36,7 +36,6 @@ var invariant = require('invariant');
  * @private
  */
 var INVALID_PROPERTY_ERRORS = {
-  content: '`content` must be set using `updateTextContentByID()`.',
   dangerouslySetInnerHTML:
     '`dangerouslySetInnerHTML` must be set using `updateInnerHTMLByID()`.',
   style: '`style` must be set using `updateStylesByID()`.'
diff --git a/src/core/ReactNativeComponent.js b/src/core/ReactNativeComponent.js
index 07371b2c8f..11bf95151d 100644
--- a/src/core/ReactNativeComponent.js
+++ b/src/core/ReactNativeComponent.js
@@ -39,7 +39,6 @@ var registrationNames = ReactEventEmitter.registrationNames;
 // For quickly matching children type, to test if can be treated as content.
 var CONTENT_TYPES = {'string': true, 'number': true};
 
-var CONTENT = keyOf({content: null});
 var DANGEROUSLY_SET_INNER_HTML = keyOf({dangerouslySetInnerHTML: null});
 var STYLE = keyOf({style: null});
 
@@ -50,14 +49,10 @@ function assertValidProps(props) {
   if (!props) {
     return;
   }
-  // Note the use of `!=` which checks for null or undefined.
-  var hasChildren = props.children != null ? 1 : 0;
-  var hasContent = props.content != null ? 1 : 0;
-  var hasInnerHTML = props.dangerouslySetInnerHTML != null ? 1 : 0;
+  // Note the use of `==` which checks for null or undefined.
   invariant(
-    hasChildren + hasContent + hasInnerHTML <= 1,
-    'Can only set one of `children`, `props.content`, or ' +
-    '`props.dangerouslySetInnerHTML`.'
+    props.children == null || props.dangerouslySetInnerHTML == null,
+    'Can only set one of `children` or `props.dangerouslySetInnerHTML`.'
   );
   invariant(
     props.style == null || typeof props.style === 'object',
@@ -156,7 +151,7 @@ ReactNativeComponent.Mixin = {
         return innerHTML.__html;
       }
     } else {
-      var contentToUse = this.props.content != null ? this.props.content :
+      var contentToUse =
         CONTENT_TYPES[typeof this.props.children] ? this.props.children : null;
       var childrenToUse = contentToUse != null ? null : this.props.children;
       if (contentToUse != null) {
@@ -219,8 +214,8 @@ ReactNativeComponent.Mixin = {
             styleUpdates[styleName] = '';
           }
         }
-      } else if (propKey === DANGEROUSLY_SET_INNER_HTML ||
-                 propKey === CONTENT) {
+      } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
+        // http://jsperf.com/emptying-speed
         ReactComponent.DOMIDOperations.updateTextContentByID(
           this._rootNodeID,
           ''
@@ -274,11 +269,6 @@ ReactNativeComponent.Mixin = {
             nextProp
           );
         }
-      } else if (propKey === CONTENT) {
-        ReactComponent.DOMIDOperations.updateTextContentByID(
-          this._rootNodeID,
-          '' + nextProp
-        );
       } else if (registrationNames[propKey]) {
         putListener(this._rootNodeID, propKey, nextProp);
       } else {
@@ -305,17 +295,10 @@ ReactNativeComponent.Mixin = {
    * @param {ReactReconcileTransaction} transaction
    */
   _updateDOMChildren: function(nextProps, transaction) {
-    var thisPropsContentType = typeof this.props.content;
-    var thisPropsContentEmpty =
-      this.props.content == null || thisPropsContentType === 'boolean';
-    var nextPropsContentType = typeof nextProps.content;
-    var nextPropsContentEmpty =
-      nextProps.content == null || nextPropsContentType === 'boolean';
-
-    var lastUsedContent = !thisPropsContentEmpty ? this.props.content :
+    var lastUsedContent =
       CONTENT_TYPES[typeof this.props.children] ? this.props.children : null;
 
-    var contentToUse = !nextPropsContentEmpty ? nextProps.content :
+    var contentToUse =
       CONTENT_TYPES[typeof nextProps.children] ? nextProps.children : null;
 
     // Note the use of `!=` which checks for null or undefined.
diff --git a/src/core/__tests__/ReactDOMIDOperations-test.js b/src/core/__tests__/ReactDOMIDOperations-test.js
index 6353993cf5..77a64475c6 100644
--- a/src/core/__tests__/ReactDOMIDOperations-test.js
+++ b/src/core/__tests__/ReactDOMIDOperations-test.js
@@ -33,8 +33,8 @@ describe('ReactDOMIDOperations', function() {
     expect(function() {
       ReactDOMIDOperations.updatePropertyByID(
         'testID',
-        keyOf({content: null}),
-        'testContent'
+        keyOf({dangerouslySetInnerHTML: null}),
+        {__html: 'testContent'}
       );
     }).toThrow();
 
diff --git a/src/core/__tests__/ReactMultiChildText-test.js b/src/core/__tests__/ReactMultiChildText-test.js
index a842d89e14..6aeea2cdd4 100644
--- a/src/core/__tests__/ReactMultiChildText-test.js
+++ b/src/core/__tests__/ReactMultiChildText-test.js
@@ -71,10 +71,6 @@ var assertSingleChild = function(instance, text) {
 };
 
 // Helpers
-var renderSingleContentChild = function(text) {
-  var d = ReactTestUtils.renderIntoDocument(<div content={text} />);
-  return d;
-};
 var renderSingleTextChild = function(text) {
   var d = ReactTestUtils.renderIntoDocument(<div>{text}</div>);
   return d;
@@ -158,11 +154,6 @@ describe('ReactMultiChildText', function() {
     assertMultiChild(d, 'hello', 'goodbye');
   });
 
-  it('should render content to single text node', function() {
-    var d = renderSingleContentChild('hello');
-    assertNodeText(d, 'hello');
-  });
-
   it('should render a single text child to a single text node', function() {
     var d = renderSingleTextChild('hello');
     assertNodeText(d, 'hello');
@@ -234,12 +225,6 @@ describe('ReactMultiChildText', function() {
     assertNodeText(d, '0');
   });
 
-  it('should render content number zero as text node', function() {
-    var d = renderSingleContentChild(0);
-    // false should act exactly as a null child
-    assertNodeText(d, '0');
-  });
-
   it('should render zero string as string child', function() {
     var d = renderMultipleTextChildren('0', 234.2);
     // false should act exactly as a null child
@@ -250,7 +235,7 @@ describe('ReactMultiChildText', function() {
     var d = renderMultipleTextChildren('0', 234.2);
     // false should act exactly as a null child
     assertMultiChild(d, '0', '234.2');
-    d.replaceProps({content: '0'});
+    d.replaceProps({children: '0'});
     assertNodeText(d, '0');
   });
 
@@ -258,7 +243,7 @@ describe('ReactMultiChildText', function() {
     var d = renderMultipleTextChildren(0, 234.2);
     // false should act exactly as a null child
     assertMultiChild(d, '0', '234.2');
-    d.replaceProps({content: 0});
+    d.replaceProps({children: 0});
     // BELOW REVEALS A BUG IN JSDOM
     // assertNodeText(d, '0');  // This works in the browser.
   });
@@ -266,7 +251,7 @@ describe('ReactMultiChildText', function() {
   it('should render multiple children then switch to inline', function() {
     var d = renderMultipleTextChildren('hello', 'goodbye');
     assertMultiChild(d, 'hello', 'goodbye');
-    d.replaceProps({content: 'hello'});
+    d.replaceProps({children: 'hello'});
     assertNodeText(d, 'hello');
   });
 
@@ -286,13 +271,6 @@ describe('ReactMultiChildText', function() {
     assertMultiChild(d, 'hello', 'goodbye');
   });
 
-  it('should render content, then switch to text components ', function() {
-    var d = renderSingleContentChild('hello');
-    assertNodeText(d, 'hello');
-    d.replaceProps({children: ['hello', 'goodbye']});
-    assertMultiChild(d, 'hello', 'goodbye');
-  });
-
   it('should render inline child, then switch to composite', function() {
     var d = renderSingleTextChild('hello');
     assertNodeText(d, 'hello');
@@ -302,9 +280,11 @@ describe('ReactMultiChildText', function() {
       .toBeCompositeComponentWithType(TestCompositeComponent);
   });
 
-  it('should throw if rendering both content and children', function() {
+  it('should throw if rendering both HTML and children', function() {
     expect(function() {
-      ReactTestUtils.renderIntoDocument(<div content="asdf">ghjkl</div>);
+      ReactTestUtils.renderIntoDocument(
+        <div dangerouslySetInnerHTML={{_html: 'abcdef'}}>ghjkl</div>
+      );
     }).toThrow();
   });
 });
diff --git a/src/core/__tests__/ReactNativeComponent-test.js b/src/core/__tests__/ReactNativeComponent-test.js
index 2611f1d442..9b6ab66df5 100644
--- a/src/core/__tests__/ReactNativeComponent-test.js
+++ b/src/core/__tests__/ReactNativeComponent-test.js
@@ -292,25 +292,11 @@ describe('ReactNativeComponent', function() {
     });
 
     it("should validate against multiple children props", function() {
-      expect(function() {
-        mountComponent({ content: '', children: '' });
-      }).toThrow(
-        'Invariant Violation: Can only set one of `children`, ' +
-        '`props.content`, or `props.dangerouslySetInnerHTML`.'
-      );
-
-      expect(function() {
-        mountComponent({ content: '', dangerouslySetInnerHTML: '' });
-      }).toThrow(
-        'Invariant Violation: Can only set one of `children`, ' +
-        '`props.content`, or `props.dangerouslySetInnerHTML`.'
-      );
-
       expect(function() {
         mountComponent({ children: '', dangerouslySetInnerHTML: '' });
       }).toThrow(
-        'Invariant Violation: Can only set one of `children`, ' +
-        '`props.content`, or `props.dangerouslySetInnerHTML`.'
+        'Invariant Violation: Can only set one of `children` or ' +
+        '`props.dangerouslySetInnerHTML`.'
       );
     });
 

From 9c35189ad196b1849d6260a60e3c0e10c5c6a1e4 Mon Sep 17 00:00:00 2001
From: JeffMo <jeffmo@fb.com>
Date: Fri, 28 Jun 2013 12:07:00 -0700
Subject: [PATCH 80/94] Add support for empty XJS expressions

---
 package.json                           |  2 +-
 vendor/fbtransform/transforms/react.js |  9 +++++----
 vendor/fbtransform/transforms/xjs.js   | 14 ++++++++------
 3 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/package.json b/package.json
index 4cbbd6b794..e531b0e7c3 100644
--- a/package.json
+++ b/package.json
@@ -37,7 +37,7 @@
   "dependencies": {
     "base62": "~0.1.1",
     "commoner": "~0.7.0",
-    "esprima": "https://github.com/facebook/esprima/tarball/ca28795124d45968e62a7b4b336d23a053ac3a84",
+    "esprima": "https://github.com/facebook/esprima/tarball/a3e0ea3979eb8d54d8bfade220c272903f928b1e",
     "recast": "~0.4.8",
     "source-map": "~0.1.22"
   },
diff --git a/vendor/fbtransform/transforms/react.js b/vendor/fbtransform/transforms/react.js
index a9495213a5..502bf5cb79 100644
--- a/vendor/fbtransform/transforms/react.js
+++ b/vendor/fbtransform/transforms/react.js
@@ -24,7 +24,8 @@ var move = require('../lib/utils').move;
 var getDocblock = require('../lib/utils').getDocblock;
 
 var FALLBACK_TAGS = require('./xjs').knownTags;
-var renderXJSExpression = require('./xjs').renderXJSExpression;
+var renderXJSExpressionContainer =
+  require('./xjs').renderXJSExpressionContainer;
 var renderXJSLiteral = require('./xjs').renderXJSLiteral;
 var quoteAttrName = require('./xjs').quoteAttrName;
 
@@ -121,7 +122,7 @@ function visitReactTag(traverse, object, path, state) {
       renderXJSLiteral(attr.value, isLast, state);
     } else {
       move(attr.value.range[0], state);
-      renderXJSExpression(traverse, attr.value, isLast, path, state);
+      renderXJSExpressionContainer(traverse, attr.value, isLast, path, state);
     }
 
     if (isLast) {
@@ -150,8 +151,8 @@ function visitReactTag(traverse, object, path, state) {
 
       if (child.type === Syntax.Literal) {
         renderXJSLiteral(child, isLast, state);
-      } else if (child.type === Syntax.XJSExpression) {
-        renderXJSExpression(traverse, child, isLast, path, state);
+      } else if (child.type === Syntax.XJSExpressionContainer) {
+        renderXJSExpressionContainer(traverse, child, isLast, path, state);
       } else {
         traverse(child, path, state);
         if (!isLast) {
diff --git a/vendor/fbtransform/transforms/xjs.js b/vendor/fbtransform/transforms/xjs.js
index 014ad24769..d1fe9117a7 100644
--- a/vendor/fbtransform/transforms/xjs.js
+++ b/vendor/fbtransform/transforms/xjs.js
@@ -15,9 +15,10 @@
  */
 /*global exports:true*/
 "use strict";
-var catchup = require('../lib/utils').catchup;
 var append = require('../lib/utils').append;
+var catchup = require('../lib/utils').catchup;
 var move = require('../lib/utils').move;
+var Syntax = require('esprima').Syntax;
 
 var knownTags = {
   a: true,
@@ -255,15 +256,16 @@ function renderXJSLiteral(object, isLast, state, start, end) {
   move(object.range[1], state);
 }
 
-function renderXJSExpression(traverse, object, isLast, path, state) {
+function renderXJSExpressionContainer(traverse, object, isLast, path, state) {
   // Plus 1 to skip `{`.
   move(object.range[0] + 1, state);
-  traverse(object.value, path, state);
-  if (!isLast) {
+  traverse(object.expression, path, state);
+  if (!isLast && object.expression.type !== Syntax.XJSEmptyExpression) {
     // If we need to append a comma, make sure to do so after the expression.
-    catchup(object.value.range[1], state);
+    catchup(object.expression.range[1], state);
     append(',', state);
   }
+
   // Minus 1 to skip `}`.
   catchup(object.range[1] - 1, state);
   move(object.range[1], state);
@@ -279,6 +281,6 @@ function quoteAttrName(attr) {
 }
 
 exports.knownTags = knownTags;
-exports.renderXJSExpression = renderXJSExpression;
+exports.renderXJSExpressionContainer = renderXJSExpressionContainer;
 exports.renderXJSLiteral = renderXJSLiteral;
 exports.quoteAttrName = quoteAttrName;

From c54900f63e3841c571e637b364efd53f9af3c9c9 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 28 Jun 2013 13:46:24 -0700
Subject: [PATCH 81/94] Fix Composition Level of Components w/o Owners

This fixes a bug with components constructed with no owners, for example:

  // Both the <div> and <span> have no owners.
  React.renderComponent(<div><span /></div>, node);

They should have a composition level of 1 and their keys should be prefixed with 0 to indicate they were created without owners. However, they currently incorrectly get a composition level of 0 (which means that //their// children will have keys prefixed with 0, which is wrong).
---
 src/core/ReactCompositeComponent.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/core/ReactCompositeComponent.js b/src/core/ReactCompositeComponent.js
index 6c4fed8fd7..a7ef000e18 100644
--- a/src/core/ReactCompositeComponent.js
+++ b/src/core/ReactCompositeComponent.js
@@ -476,8 +476,7 @@ var ReactCompositeComponentMixin = {
     this.state = null;
     this._pendingState = null;
     this._compositeLifeCycleState = null;
-    this._compositionLevel = ReactCurrentOwner.current ?
-      ReactCurrentOwner.getDepth() + 1 : 0;
+    this._compositionLevel = ReactCurrentOwner.getDepth() + 1;
   },
 
   /**

From 65568814179d2a28cc83d68a5e467c24b86da2f6 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 28 Jun 2013 13:46:29 -0700
Subject: [PATCH 82/94] Throw on Missing Elements

This changes React to throw when `ReactID.getNode()` fails to find a node. This method is used by two call sites:

 - Implements `ReactComponent#getDOMNode`. This method already throws if a component is not mounted, and //all mounted components should be able to find their rendered root nodes//.
 - Used by `ReactDOMIDOperations`. These call sites aleady assume that `getNode` returns a non-null. Currently, if the node is not found, this is the site that fatals (and the stack trace is much harder to debug).

The error message should make it //a lot// easier to debug unexpected DOM trees. In particular, this will help track down all the places where the browser inserts `<tbody>` unexpectedly.
---
 src/core/ReactComponent.js                    |  2 +-
 src/core/ReactID.js                           | 13 ++++------
 src/core/ReactInstanceHandles.js              | 22 ++++++++++++-----
 src/core/ReactMount.js                        |  7 +++---
 .../__tests__/ReactInstanceHandles-test.js    | 24 +++++++++++++++++++
 5 files changed, 48 insertions(+), 20 deletions(-)

diff --git a/src/core/ReactComponent.js b/src/core/ReactComponent.js
index db672385df..addad00ab5 100644
--- a/src/core/ReactComponent.js
+++ b/src/core/ReactComponent.js
@@ -276,7 +276,7 @@ var ReactComponent = {
     /**
      * Returns the DOM node rendered by this component.
      *
-     * @return {?DOMElement} The root node of this component.
+     * @return {DOMElement} The root node of this component.
      * @final
      * @protected
      */
diff --git a/src/core/ReactID.js b/src/core/ReactID.js
index 4be8bdca25..d677b14e8a 100644
--- a/src/core/ReactID.js
+++ b/src/core/ReactID.js
@@ -85,19 +85,14 @@ function setID(node, id) {
  * Finds the node with the supplied React-generated DOM ID.
  *
  * @param {string} id A React-generated DOM ID.
- * @return {?DOMElement} DOM node with the suppled `id`.
+ * @return {DOMElement} DOM node with the suppled `id`.
  * @internal
  */
 function getNode(id) {
-  if (nodeCache.hasOwnProperty(id)) {
-    var node = nodeCache[id];
-    if (isValid(node, id)) {
-      return node;
-    }
+  if (!nodeCache.hasOwnProperty(id) || !isValid(nodeCache[id], id)) {
+    nodeCache[id] = ReactMount.findReactNodeByID(id);
   }
-
-  return nodeCache[id] =
-    ReactMount.findReactRenderedDOMNodeSlow(id);
+  return nodeCache[id];
 }
 
 /**
diff --git a/src/core/ReactInstanceHandles.js b/src/core/ReactInstanceHandles.js
index af508207e3..f9678056ff 100644
--- a/src/core/ReactInstanceHandles.js
+++ b/src/core/ReactInstanceHandles.js
@@ -280,21 +280,31 @@ var ReactInstanceHandles = {
    *
    * @param {DOMEventTarget} ancestorNode Search from this root.
    * @pararm {string} id ID of the DOM representation of the component.
-   * @return {?DOMEventTarget} DOM node with the supplied `id`, if one exists.
+   * @return {DOMEventTarget} DOM node with the supplied `id`.
    * @internal
    */
   findComponentRoot: function(ancestorNode, id) {
     var child = ancestorNode.firstChild;
     while (child) {
       var childID = ReactID.getID(child);
-      if (id === childID) {
-        return child;
-      } else if (childID && isAncestorIDOf(childID, id)) {
-        return ReactInstanceHandles.findComponentRoot(child, id);
+      if (childID) {
+        if (id === childID) {
+          return child;
+        } else if (isAncestorIDOf(childID, id)) {
+          return ReactInstanceHandles.findComponentRoot(child, id);
+        }
       }
       child = child.nextSibling;
     }
-    // Effectively: return null;
+    invariant(
+      false,
+      'findComponentRoot: Unable to find element by React ID, `%s`. This ' +
+      'indicates that someone (or the browser) has mutated the DOM tree in ' +
+      'an unexpected way. Try inspecting the child nodes of the element with ' +
+      'React ID, `%s`.',
+      id,
+      ReactID.getID(ancestorNode)
+    );
   },
 
   /**
diff --git a/src/core/ReactMount.js b/src/core/ReactMount.js
index 56c5c54782..62d9bc6b13 100644
--- a/src/core/ReactMount.js
+++ b/src/core/ReactMount.js
@@ -269,13 +269,12 @@ var ReactMount = {
   },
 
   /**
-   * Given the ID of a DOM node rendered by a React component, finds the root
-   * DOM node of the React component.
+   * Finds an element rendered by React with the supplied ID.
    *
    * @param {string} id ID of a DOM node in the React component.
-   * @return {?DOMElement} Root DOM node of the React component.
+   * @return {DOMElement} Root DOM node of the React component.
    */
-  findReactRenderedDOMNodeSlow: function(id) {
+  findReactNodeByID: function(id) {
     var reactRoot = ReactMount.findReactContainerForID(id);
     return ReactInstanceHandles.findComponentRoot(reactRoot, id);
   }
diff --git a/src/core/__tests__/ReactInstanceHandles-test.js b/src/core/__tests__/ReactInstanceHandles-test.js
index 4daef67300..331b47a183 100644
--- a/src/core/__tests__/ReactInstanceHandles-test.js
+++ b/src/core/__tests__/ReactInstanceHandles-test.js
@@ -121,6 +121,30 @@ describe('ReactInstanceHandles', function() {
         )
       ).toBe(childNodeB);
     });
+
+    it('should throw if a rendered element cannot be found', function() {
+      var parentNode = document.createElement('table');
+      var childNodeA = document.createElement('tbody');
+      var childNodeB = document.createElement('tr');
+      parentNode.appendChild(childNodeA);
+      childNodeA.appendChild(childNodeB);
+
+      ReactID.setID(parentNode, '.react[0]');
+      // No ID on `childNodeA`, it was "rendered by the browser".
+      ReactID.setID(childNodeB, '.react[0].1:0');
+
+      expect(function() {
+        ReactInstanceHandles.findComponentRoot(
+          parentNode,
+          ReactID.getID(childNodeB)
+        );
+      }).toThrow(
+        'Invariant Violation: findComponentRoot: Unable to find element by ' +
+        'React ID, `.react[0].1:0`. This indicates that someone (or the ' +
+        'browser) has mutated the DOM tree in an unexpected way. Try ' +
+        'inspecting the child nodes of the element with React ID, `.react[0]`.'
+      );
+    });
   });
 
   describe('getReactRootIDFromNodeID', function() {

From 8bc2abd367232eca66e4d38ff63b335c8cf23c45 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 28 Jun 2013 13:46:33 -0700
Subject: [PATCH 83/94] .reactRoot[base10] -> .r[base36]

Just a bit of byte savings for server rendering. Props to @benjamn for the base36 idea (and for making this diff easy).

With a little work we could probably get rid of the .r as well.
---
 src/core/ReactInstanceHandles.js              |  4 +--
 src/core/ReactMount.js                        |  2 +-
 src/core/__tests__/ReactIdentity-test.js      | 26 +++++++++----------
 .../__tests__/ReactInstanceHandles-test.js    |  4 +--
 .../__tests__/ResponderEventPlugin-test.js    |  6 ++---
 5 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/src/core/ReactInstanceHandles.js b/src/core/ReactInstanceHandles.js
index f9678056ff..000856604b 100644
--- a/src/core/ReactInstanceHandles.js
+++ b/src/core/ReactInstanceHandles.js
@@ -48,7 +48,7 @@ var GLOBAL_MOUNT_POINT_MAX = 9999999;
  * @internal
  */
 function getReactRootIDString(index) {
-  return '.reactRoot[' + index + ']';
+  return SEPARATOR + 'r[' + index.toString(36) + ']';
 }
 
 /**
@@ -316,7 +316,7 @@ var ReactInstanceHandles = {
    * @internal
    */
   getReactRootIDFromNodeID: function(id) {
-    var regexResult = /\.reactRoot\[[^\]]+\]/.exec(id);
+    var regexResult = /\.r\[[^\]]+\]/.exec(id);
     return regexResult && regexResult[0];
   },
 
diff --git a/src/core/ReactMount.js b/src/core/ReactMount.js
index 62d9bc6b13..14f93055b9 100644
--- a/src/core/ReactMount.js
+++ b/src/core/ReactMount.js
@@ -56,7 +56,7 @@ function getReactRootID(container) {
  *   ReactMount.renderComponent(component, $('container'));
  *
  *   <div id="container">                   <-- Supplied `container`.
- *     <div data-reactid=".reactRoot[3]">   <-- Rendered reactRoot of React
+ *     <div data-reactid=".r[3]">           <-- Rendered reactRoot of React
  *       // ...                                 component.
  *     </div>
  *   </div>
diff --git a/src/core/__tests__/ReactIdentity-test.js b/src/core/__tests__/ReactIdentity-test.js
index 9edf0f73ef..36998e9f62 100644
--- a/src/core/__tests__/ReactIdentity-test.js
+++ b/src/core/__tests__/ReactIdentity-test.js
@@ -34,7 +34,7 @@ describe('ReactIdentity', function() {
     ReactID = require('ReactID');
   });
 
-  var idExp = /^\.reactRoot\[\d+\](.*)$/;
+  var idExp = /^\.r\[.+?\](.*)$/;
   function checkId(child, expectedId) {
     var actual = idExp.exec(ReactID.getID(child));
     var expected = idExp.exec(expectedId);
@@ -55,8 +55,8 @@ describe('ReactIdentity', function() {
     React.renderComponent(instance, document.createElement('div'));
     var node = instance.getDOMNode();
     reactComponentExpect(instance).toBeDOMComponentWithChildCount(2);
-    checkId(node.childNodes[0], '.reactRoot[0].[0]{first}');
-    checkId(node.childNodes[1], '.reactRoot[0].[0]{second}');
+    checkId(node.childNodes[0], '.r[0].[0]{first}');
+    checkId(node.childNodes[1], '.r[0].[0]{second}');
   });
 
   it('should allow key property to express identity', function() {
@@ -71,10 +71,10 @@ describe('ReactIdentity', function() {
     React.renderComponent(instance, document.createElement('div'));
     var node = instance.getDOMNode();
     reactComponentExpect(instance).toBeDOMComponentWithChildCount(4);
-    checkId(node.childNodes[0], '.reactRoot[0].[0:apple]');
-    checkId(node.childNodes[1], '.reactRoot[0].[0:banana]');
-    checkId(node.childNodes[2], '.reactRoot[0].[0:0]');
-    checkId(node.childNodes[3], '.reactRoot[0].[0:123]');
+    checkId(node.childNodes[0], '.r[0].[0:apple]');
+    checkId(node.childNodes[1], '.r[0].[0:banana]');
+    checkId(node.childNodes[2], '.r[0].[0:0]');
+    checkId(node.childNodes[3], '.r[0].[0:123]');
   });
 
   it('should use instance identity', function() {
@@ -95,15 +95,15 @@ describe('ReactIdentity', function() {
     React.renderComponent(instance, document.createElement('div'));
     var node = instance.getDOMNode();
     reactComponentExpect(instance).toBeDOMComponentWithChildCount(3);
-    checkId(node.childNodes[0], '.reactRoot[0].[0:wrap1]');
+    checkId(node.childNodes[0], '.r[0].[0:wrap1]');
     checkId(
       node.childNodes[0].firstChild,
-      '.reactRoot[0].[0:wrap1].[0:squirrel]'
+      '.r[0].[0:wrap1].[0:squirrel]'
     );
-    checkId(node.childNodes[1], '.reactRoot[0].[0:wrap2]');
-    checkId(node.childNodes[1].firstChild, '.reactRoot[0].[0:wrap2].[0:bunny]');
-    checkId(node.childNodes[2], '.reactRoot[0].[0:2]');
-    checkId(node.childNodes[2].firstChild, '.reactRoot[0].[0:2].[0:chipmunk]');
+    checkId(node.childNodes[1], '.r[0].[0:wrap2]');
+    checkId(node.childNodes[1].firstChild, '.r[0].[0:wrap2].[0:bunny]');
+    checkId(node.childNodes[2], '.r[0].[0:2]');
+    checkId(node.childNodes[2].firstChild, '.r[0].[0:2].[0:chipmunk]');
   });
 
   it('should let restructured components retain their uniqueness', function() {
diff --git a/src/core/__tests__/ReactInstanceHandles-test.js b/src/core/__tests__/ReactInstanceHandles-test.js
index 331b47a183..4cde75ab5d 100644
--- a/src/core/__tests__/ReactInstanceHandles-test.js
+++ b/src/core/__tests__/ReactInstanceHandles-test.js
@@ -149,8 +149,8 @@ describe('ReactInstanceHandles', function() {
 
   describe('getReactRootIDFromNodeID', function() {
     it('should support strings', function() {
-      var test = '.reactRoot[s_0_1][0]..[1]';
-      var expected = '.reactRoot[s_0_1]';
+      var test = '.r[s_0_1][0]..[1]';
+      var expected = '.r[s_0_1]';
       var actual = ReactInstanceHandles.getReactRootIDFromNodeID(test);
       expect(actual).toEqual(expected);
     });
diff --git a/src/eventPlugins/__tests__/ResponderEventPlugin-test.js b/src/eventPlugins/__tests__/ResponderEventPlugin-test.js
index 6917e6e8b7..5db1e6138b 100644
--- a/src/eventPlugins/__tests__/ResponderEventPlugin-test.js
+++ b/src/eventPlugins/__tests__/ResponderEventPlugin-test.js
@@ -25,9 +25,9 @@ var ReactInstanceHandles;
 var ResponderEventPlugin;
 var SyntheticEvent;
 
-var GRANDPARENT_ID = '.reactRoot[0]';
-var PARENT_ID = '.reactRoot[0].0';
-var CHILD_ID = '.reactRoot[0].0.0';
+var GRANDPARENT_ID = '.r[0]';
+var PARENT_ID = '.r[0].0';
+var CHILD_ID = '.r[0].0.0';
 
 var topLevelTypes;
 var responderEventTypes;

From ee21a604f31020fbaa898a4d0d61dc487198ce82 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Paul=20O=E2=80=99Shannessy?= <paul@oshannessy.com>
Date: Fri, 28 Jun 2013 14:52:40 -0700
Subject: [PATCH 84/94] Delete files that accidentally got merged in
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ಠ_ಠ
---
 React/$.js                                    |   46 -
 React/AbstractEvent.js                        |  276 --
 React/AnalyticsEventPluginFactory.js          |  225 --
 React/BrowserEnv.js                           |   36 -
 React/CSSProperty.js                          |   38 -
 React/CSSPropertyOperations.js                |   81 -
 React/CallbackRegistry.js                     |   72 -
 React/DOMChildrenOperations.js                |  146 -
 React/DOMProperty.js                          |  263 --
 React/DOMPropertyOperations.js                |   93 -
 React/Danger.js                               |  158 -
 React/DefaultEventPluginOrder.js              |   40 -
 React/EnterLeaveEventPlugin.js                |  102 -
 React/EventConstants.js                       |   57 -
 React/EventListener.js                        |   59 -
 React/EventPluginHub.js                       |  324 --
 React/EventPluginUtils.js                     |  206 --
 React/EventPropagators.js                     |  180 --
 React/ExecutionEnvironment.js                 |   43 -
 React/ImmutableObject.js                      |  168 --
 React/NormalizedEventListener.js              |   88 -
 React/OrderedMap.js                           |  514 ----
 React/PooledClass.js                          |  101 -
 React/React.js                                |   45 -
 React/ReactComponent.js                       |  402 ---
 React/ReactCompositeComponent.js              |  836 ------
 React/ReactCurrentOwner.js                    |   37 -
 React/ReactDOM.js                             |  148 -
 React/ReactDOMForm.js                         |   52 -
 React/ReactDOMIDOperations.js                 |  166 --
 React/ReactDOMNodeCache.js                    |   52 -
 React/ReactDefaultInjection.js                |   59 -
 React/ReactEvent.js                           |  321 --
 React/ReactEventTopLevelCallback.js           |   74 -
 React/ReactInputSelection.js                  |  180 --
 React/ReactInstanceHandles.js                 |  326 ---
 React/ReactMount.js                           |  232 --
 React/ReactMultiChild.js                      |  208 --
 React/ReactNativeComponent.js                 |  331 ---
 React/ReactOnDOMReady.js                      |   95 -
 React/ReactOwner.js                           |  146 -
 React/ReactPropTransferer.js                  |  114 -
 React/ReactProps.js                           |  157 -
 React/ReactReconcileTransaction.js            |  161 -
 React/ReactStateSetters.js                    |  111 -
 React/ReactTestUtils.js                       |  284 --
 React/ReactTextComponent.js                   |   85 -
 React/ResponderEventPlugin.js                 |  312 --
 React/SimpleEventPlugin.js                    |  232 --
 React/TapEventPlugin.js                       |   89 -
 React/TouchEventUtils.js                      |   42 -
 React/Transaction.js                          |  252 --
 React/accumulate.js                           |   70 -
 React/copyProperties.js                       |   54 -
 React/core/__tests__/ReactBind-test.js        |    0
 React/core/__tests__/ReactComponent-test.js   |    0
 .../ReactComponentFlattenChildren-test.js     |    1 -
 .../__tests__/ReactComponentLifeCycle-test.js |    0
 .../__tests__/ReactCompositeComponent-test.js |    0
 ...actCompositeComponentDOMMinimalism-test.js |  113 -
 .../ReactCompositeComponentMixin-test.js      |   82 -
 .../ReactCompositeComponentSpec-test.js       |    0
 .../ReactCompositeComponentState-test.js      |  169 --
 ...actCompositeComponentTransferProps-test.js |    0
 React/core/__tests__/ReactDOM-test.js         |  112 -
 .../__tests__/ReactDOMIDOperations-test.js    |   65 -
 React/core/__tests__/ReactEvent-test.js       |  335 ---
 React/core/__tests__/ReactIdentity-test.js    |    1 -
 .../__tests__/ReactInstanceHandles-test.js    |    0
 React/core/__tests__/ReactMount-test.js       |    1 -
 .../__tests__/ReactMountDestruction-test.js   |   64 -
 .../ReactMultiChildReconcile-test.js          |    0
 .../__tests__/ReactMultiChildText-test.js     |    0
 .../__tests__/ReactNativeComponent-test.js    |  242 --
 React/core/__tests__/ReactProps-test.js       |  142 -
 .../core/__tests__/ReactStateSetters-test.js  |  162 -
 React/core/__tests__/refs-destruction-test.js |    0
 React/core/__tests__/refs-test.js             |    0
 React/createObjectFrom.js                     |   63 -
 React/cx.js                                   |   44 -
 React/dangerousStyleValue.js                  |   51 -
 .../__tests__/CSSPropertyOperations-test.js   |    1 -
 .../__tests__/DOMPropertyOperations-test.js   |    1 -
 .../__tests__/CSSPropertyOperations-test.js   |   52 -
 .../__tests__/DOMPropertyOperations-test.js   |  129 -
 React/emptyFunction.js                        |   50 -
 .../__tests__/ReactServerRendering-test.js    |    1 -
 React/erx.js                                  |   71 -
 React/escapeTextForBrowser.js                 |   61 -
 .../__tests__/EventPluginRegistry-test.js     |    1 -
 .../__tests__/SyntheticEvent-test.js          |    1 -
 .../__tests__/SyntheticWheelEvent-test.js     |    1 -
 .../__tests__/AnalyticsEventPlugin-test.js    |    0
 .../__tests__/ResponderEventPlugin-test.js    |  501 ----
 React/ex.js                                   |   49 -
 React/flattenChildren.js                      |   93 -
 React/forEachAccumulated.js                   |   36 -
 React/ge.js                                   |   76 -
 React/getDOMNodeID.js                         |   38 -
 React/getTextContentAccessor.js               |   40 -
 React/hasArrayNature.js                       |   52 -
 React/hyphenate.js                            |   35 -
 React/insertNodeAt.js                         |   46 -
 React/invariant.js                            |   54 -
 React/isEventSupported.js                     |   62 -
 React/joinClasses.js                          |   44 -
 React/keyMirror.js                            |   56 -
 React/keyOf.js                                |   41 -
 React/memoizeStringOnly.js                    |   39 -
 React/merge.js                                |   37 -
 React/mergeDeep.js                            |   53 -
 React/mergeDeepInto.js                        |  238 --
 React/mergeHelpers.js                         |  162 -
 React/mergeInto.js                            |   45 -
 React/mixInto.js                              |   34 -
 React/mock-modules.js                         |   33 -
 React/mocks.js                                |  431 ---
 React/objFilter.js                            |   48 -
 React/objMap.js                               |   47 -
 React/objMapKeyVal.js                         |   47 -
 React/reactComponentExpect.js                 |  190 --
 React/test/all.js                             |   57 -
 React/test/mock-timers.js                     |  226 --
 React/throwIf.js                              |   27 -
 React/utils/__tests__/ImmutableObject-test.js |  293 --
 React/utils/__tests__/OrderedMap-test.js      |  944 ------
 React/utils/__tests__/Transaction-test.js     |  314 --
 React/utils/__tests__/joinClasses-test.js     |   57 -
 React/utils/__tests__/keyMirror-test.js       |   71 -
 React/utils/__tests__/mapChildren-test.js     |    1 -
 .../utils/__tests__/memoizeStringOnly-test.js |   37 -
 React/utils/__tests__/mergeFuncs-test.js      |  983 -------
 React/utils/__tests__/objFilter-test.js       |   88 -
 React/utils/__tests__/objMap-test.js          |  113 -
 React/vendor/error/__tests__/erx-test.js      |   58 -
 React/vendor/error/__tests__/ex-test.js       |   43 -
 all/HtmlReporter.js                           |  168 --
 all/PrintReporter.js                          |  128 -
 all/ReporterView.js                           |  166 --
 all/SpecView.js                               |   81 -
 all/SuiteView.js                              |   24 -
 all/all.js                                    |   38 -
 all/console.js                                |   92 -
 all/diff.js                                   |  349 ---
 all/jasmine-html.js                           |  683 -----
 all/jasmine-support.js                        |  127 -
 all/jasmine.js                                | 2597 -----------------
 all/phantom.js                                |   44 -
 148 files changed, 21441 deletions(-)
 delete mode 100644 React/$.js
 delete mode 100644 React/AbstractEvent.js
 delete mode 100644 React/AnalyticsEventPluginFactory.js
 delete mode 100644 React/BrowserEnv.js
 delete mode 100644 React/CSSProperty.js
 delete mode 100644 React/CSSPropertyOperations.js
 delete mode 100644 React/CallbackRegistry.js
 delete mode 100644 React/DOMChildrenOperations.js
 delete mode 100644 React/DOMProperty.js
 delete mode 100644 React/DOMPropertyOperations.js
 delete mode 100644 React/Danger.js
 delete mode 100644 React/DefaultEventPluginOrder.js
 delete mode 100644 React/EnterLeaveEventPlugin.js
 delete mode 100644 React/EventConstants.js
 delete mode 100644 React/EventListener.js
 delete mode 100644 React/EventPluginHub.js
 delete mode 100644 React/EventPluginUtils.js
 delete mode 100644 React/EventPropagators.js
 delete mode 100644 React/ExecutionEnvironment.js
 delete mode 100644 React/ImmutableObject.js
 delete mode 100644 React/NormalizedEventListener.js
 delete mode 100644 React/OrderedMap.js
 delete mode 100644 React/PooledClass.js
 delete mode 100644 React/React.js
 delete mode 100644 React/ReactComponent.js
 delete mode 100644 React/ReactCompositeComponent.js
 delete mode 100644 React/ReactCurrentOwner.js
 delete mode 100644 React/ReactDOM.js
 delete mode 100644 React/ReactDOMForm.js
 delete mode 100644 React/ReactDOMIDOperations.js
 delete mode 100644 React/ReactDOMNodeCache.js
 delete mode 100644 React/ReactDefaultInjection.js
 delete mode 100644 React/ReactEvent.js
 delete mode 100644 React/ReactEventTopLevelCallback.js
 delete mode 100644 React/ReactInputSelection.js
 delete mode 100644 React/ReactInstanceHandles.js
 delete mode 100644 React/ReactMount.js
 delete mode 100644 React/ReactMultiChild.js
 delete mode 100644 React/ReactNativeComponent.js
 delete mode 100644 React/ReactOnDOMReady.js
 delete mode 100644 React/ReactOwner.js
 delete mode 100644 React/ReactPropTransferer.js
 delete mode 100644 React/ReactProps.js
 delete mode 100644 React/ReactReconcileTransaction.js
 delete mode 100644 React/ReactStateSetters.js
 delete mode 100644 React/ReactTestUtils.js
 delete mode 100644 React/ReactTextComponent.js
 delete mode 100644 React/ResponderEventPlugin.js
 delete mode 100644 React/SimpleEventPlugin.js
 delete mode 100644 React/TapEventPlugin.js
 delete mode 100644 React/TouchEventUtils.js
 delete mode 100644 React/Transaction.js
 delete mode 100644 React/accumulate.js
 delete mode 100644 React/copyProperties.js
 delete mode 100644 React/core/__tests__/ReactBind-test.js
 delete mode 100644 React/core/__tests__/ReactComponent-test.js
 delete mode 100644 React/core/__tests__/ReactComponentFlattenChildren-test.js
 delete mode 100644 React/core/__tests__/ReactComponentLifeCycle-test.js
 delete mode 100644 React/core/__tests__/ReactCompositeComponent-test.js
 delete mode 100644 React/core/__tests__/ReactCompositeComponentDOMMinimalism-test.js
 delete mode 100644 React/core/__tests__/ReactCompositeComponentMixin-test.js
 delete mode 100644 React/core/__tests__/ReactCompositeComponentSpec-test.js
 delete mode 100644 React/core/__tests__/ReactCompositeComponentState-test.js
 delete mode 100644 React/core/__tests__/ReactCompositeComponentTransferProps-test.js
 delete mode 100644 React/core/__tests__/ReactDOM-test.js
 delete mode 100644 React/core/__tests__/ReactDOMIDOperations-test.js
 delete mode 100644 React/core/__tests__/ReactEvent-test.js
 delete mode 100644 React/core/__tests__/ReactIdentity-test.js
 delete mode 100644 React/core/__tests__/ReactInstanceHandles-test.js
 delete mode 100644 React/core/__tests__/ReactMount-test.js
 delete mode 100644 React/core/__tests__/ReactMountDestruction-test.js
 delete mode 100644 React/core/__tests__/ReactMultiChildReconcile-test.js
 delete mode 100644 React/core/__tests__/ReactMultiChildText-test.js
 delete mode 100644 React/core/__tests__/ReactNativeComponent-test.js
 delete mode 100644 React/core/__tests__/ReactProps-test.js
 delete mode 100644 React/core/__tests__/ReactStateSetters-test.js
 delete mode 100644 React/core/__tests__/refs-destruction-test.js
 delete mode 100644 React/core/__tests__/refs-test.js
 delete mode 100644 React/createObjectFrom.js
 delete mode 100644 React/cx.js
 delete mode 100644 React/dangerousStyleValue.js
 delete mode 100644 React/dom/__tests__/CSSPropertyOperations-test.js
 delete mode 100644 React/dom/__tests__/DOMPropertyOperations-test.js
 delete mode 100644 React/domUtils/__tests__/CSSPropertyOperations-test.js
 delete mode 100644 React/domUtils/__tests__/DOMPropertyOperations-test.js
 delete mode 100644 React/emptyFunction.js
 delete mode 100644 React/environment/__tests__/ReactServerRendering-test.js
 delete mode 100644 React/erx.js
 delete mode 100644 React/escapeTextForBrowser.js
 delete mode 100644 React/event/__tests__/EventPluginRegistry-test.js
 delete mode 100644 React/event/synthetic/__tests__/SyntheticEvent-test.js
 delete mode 100644 React/event/synthetic/__tests__/SyntheticWheelEvent-test.js
 delete mode 100644 React/eventPlugins/__tests__/AnalyticsEventPlugin-test.js
 delete mode 100644 React/eventPlugins/__tests__/ResponderEventPlugin-test.js
 delete mode 100644 React/ex.js
 delete mode 100644 React/flattenChildren.js
 delete mode 100644 React/forEachAccumulated.js
 delete mode 100644 React/ge.js
 delete mode 100644 React/getDOMNodeID.js
 delete mode 100644 React/getTextContentAccessor.js
 delete mode 100644 React/hasArrayNature.js
 delete mode 100644 React/hyphenate.js
 delete mode 100644 React/insertNodeAt.js
 delete mode 100644 React/invariant.js
 delete mode 100644 React/isEventSupported.js
 delete mode 100644 React/joinClasses.js
 delete mode 100644 React/keyMirror.js
 delete mode 100644 React/keyOf.js
 delete mode 100644 React/memoizeStringOnly.js
 delete mode 100644 React/merge.js
 delete mode 100644 React/mergeDeep.js
 delete mode 100644 React/mergeDeepInto.js
 delete mode 100644 React/mergeHelpers.js
 delete mode 100644 React/mergeInto.js
 delete mode 100644 React/mixInto.js
 delete mode 100644 React/mock-modules.js
 delete mode 100644 React/mocks.js
 delete mode 100644 React/objFilter.js
 delete mode 100644 React/objMap.js
 delete mode 100644 React/objMapKeyVal.js
 delete mode 100644 React/reactComponentExpect.js
 delete mode 100644 React/test/all.js
 delete mode 100644 React/test/mock-timers.js
 delete mode 100644 React/throwIf.js
 delete mode 100644 React/utils/__tests__/ImmutableObject-test.js
 delete mode 100644 React/utils/__tests__/OrderedMap-test.js
 delete mode 100644 React/utils/__tests__/Transaction-test.js
 delete mode 100644 React/utils/__tests__/joinClasses-test.js
 delete mode 100644 React/utils/__tests__/keyMirror-test.js
 delete mode 100644 React/utils/__tests__/mapChildren-test.js
 delete mode 100644 React/utils/__tests__/memoizeStringOnly-test.js
 delete mode 100644 React/utils/__tests__/mergeFuncs-test.js
 delete mode 100644 React/utils/__tests__/objFilter-test.js
 delete mode 100644 React/utils/__tests__/objMap-test.js
 delete mode 100644 React/vendor/error/__tests__/erx-test.js
 delete mode 100644 React/vendor/error/__tests__/ex-test.js
 delete mode 100644 all/HtmlReporter.js
 delete mode 100644 all/PrintReporter.js
 delete mode 100644 all/ReporterView.js
 delete mode 100644 all/SpecView.js
 delete mode 100644 all/SuiteView.js
 delete mode 100644 all/all.js
 delete mode 100644 all/console.js
 delete mode 100644 all/diff.js
 delete mode 100644 all/jasmine-html.js
 delete mode 100644 all/jasmine-support.js
 delete mode 100644 all/jasmine.js
 delete mode 100644 all/phantom.js

diff --git a/React/$.js b/React/$.js
deleted file mode 100644
index 1c87c426e9..0000000000
--- a/React/$.js
+++ /dev/null
@@ -1,46 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule $
- */
-
-var ge = require("./ge");
-
-/**
- * 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.
- *
- * If you're not sure whether or not the element exists, use ge instead, and
- * manually check for the element's existence in your application code.
- */
-function $(arg) {
-  var element = ge(arg);
-  if (!element) {
-    if (typeof arg == 'undefined') {
-      arg = 'undefined';
-    } else if (arg === null) {
-      arg = 'null';
-    }
-    throw new Error(
-      'Tried to get element "' + arg.toString() + '" but it is not present ' +
-      'on the page.'
-    );
-  }
-  return element;
-}
-
-module.exports = $;
diff --git a/React/AbstractEvent.js b/React/AbstractEvent.js
deleted file mode 100644
index efbaf91ea6..0000000000
--- a/React/AbstractEvent.js
+++ /dev/null
@@ -1,276 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule AbstractEvent
- */
-
-"use strict";
-
-var BrowserEnv = require("./BrowserEnv");
-var PooledClass = require("./PooledClass");
-var TouchEventUtils = require("./TouchEventUtils");
-
-var throwIf = require("./throwIf");
-
-
-// Only accessed in __DEV__
-var CLONE_TYPE_ERR;
-if (true) {
-  CLONE_TYPE_ERR =
-    'You may only clone instances of AbstractEvent for ' +
-    'persistent references. Check yourself.';
-}
-var MAX_POOL_SIZE = 20;
-
-/**
- * AbstractEvent copy constructor. @see `PooledClass`. Provides a single place
- * to define all cross browser normalization of DOM events. Does not attempt to
- * extend a native event, rather creates a completely new object that has a
- * reference to the nativeEvent through .nativeEvent member. The property .data
- * should hold all data that is extracted from the event in a cross browser
- * manner. Application code should use the data field when possible, not the
- * unreliable native event.
- */
-function AbstractEvent(
-    abstractEventType,
-    abstractTargetID,  // Allows the abstract target to differ from native.
-    originatingTopLevelEventType,
-    nativeEvent,
-    data) {
-  this.type = abstractEventType;
-  this.abstractTargetID = abstractTargetID || '';
-  this.originatingTopLevelEventType = originatingTopLevelEventType;
-  this.nativeEvent = nativeEvent;
-  this.data = data;
-  // TODO: Deprecate storing target - doesn't always make sense for some types
-  this.target = nativeEvent && nativeEvent.target;
-
-  /**
-   * As a performance optimization, we tag the existing event with the listeners
-   * (or listener [singular] if only one). This avoids having to package up an
-   * abstract event along with the set of listeners into a wrapping "dispatch"
-   * object. No one should ever read this property except event system and
-   * plugin/dispatcher code. We also tag the abstract event with a parallel
-   * ID array. _dispatchListeners[i] is being dispatched to a DOM node at ID
-   * _dispatchIDs[i]. The lengths should never, ever, ever be different.
-   */
-  this._dispatchListeners = null;
-  this._dispatchIDs = null;
-
-  this.isPropagationStopped = false;
-}
-
-/** `PooledClass` looks for this. */
-AbstractEvent.poolSize = MAX_POOL_SIZE;
-
-/**
- * `PooledClass` looks for `destructor` on each instance it releases. We need to
- * ensure that we remove all references to listeners which could trap large
- * amounts of memory in their closures.
- */
-AbstractEvent.prototype.destructor = function() {
-  this.target = null;
-  this._dispatchListeners = null;
-  this._dispatchIDs = null;
-};
-
-/**
- * Enhance the `AbstractEvent` class to have pooling abilities. We instruct
- * `PooledClass` that our copy constructor accepts five arguments (this is just
- * a performance optimization). These objects are instantiated frequently.
- */
-PooledClass.addPoolingTo(AbstractEvent, PooledClass.fiveArgumentPooler);
-
-AbstractEvent.prototype.stopPropagation = function() {
-  this.isPropagationStopped = true;
-  if (this.nativeEvent.stopPropagation) {
-    this.nativeEvent.stopPropagation();
-  }
-  // IE8 only understands cancelBubble, not stopPropagation().
-  this.nativeEvent.cancelBubble = true;
-};
-
-AbstractEvent.prototype.preventDefault = function() {
-  AbstractEvent.preventDefaultOnNativeEvent(this.nativeEvent);
-};
-
-/**
- * Utility function for preventing default in cross browser manner.
- */
-AbstractEvent.preventDefaultOnNativeEvent = function(nativeEvent) {
-  if (nativeEvent.preventDefault) {
-    nativeEvent.preventDefault();
-  } else {
-    nativeEvent.returnValue = false;
-  }
-};
-
-/**
- * @param {Element} target The target element.
- */
-AbstractEvent.normalizeScrollDataFromTarget = function(target) {
-  return {
-    scrollTop: target.scrollTop,
-    scrollLeft: target.scrollLeft,
-    clientWidth: target.clientWidth,
-    clientHeight: target.clientHeight,
-    scrollHeight: target.scrollHeight,
-    scrollWidth: target.scrollWidth
-  };
-};
-
-/*
- * There are some normalizations that need to happen for various browsers. In
- * addition to replacing the general event fixing with a framework such as
- * jquery, we need to normalize mouse events here. Code below is mostly borrowed
- * from: jScrollPane/script/jquery.mousewheel.js
- */
-AbstractEvent.normalizeMouseWheelData = function(nativeEvent) {
-  var delta = 0;
-  var deltaX = 0;
-  var deltaY = 0;
-
-  /* traditional scroll wheel data */
-  if ( nativeEvent.wheelDelta ) { delta = nativeEvent.wheelDelta/120; }
-  if ( nativeEvent.detail     ) { delta = -nativeEvent.detail/3; }
-
-  /* Multidimensional scroll (touchpads) with deltas */
-  deltaY = delta;
-
-  /* Gecko based browsers */
-  if (nativeEvent.axis !== undefined &&
-      nativeEvent.axis === nativeEvent.HORIZONTAL_AXIS ) {
-    deltaY = 0;
-    deltaX = -delta;
-  }
-
-  /* Webkit based browsers */
-  if (nativeEvent.wheelDeltaY !== undefined ) {
-    deltaY = nativeEvent.wheelDeltaY/120;
-  }
-  if (nativeEvent.wheelDeltaX !== undefined ) {
-    deltaX = -nativeEvent.wheelDeltaX/120;
-  }
-
-  return { delta: delta, deltaX: deltaX, deltaY: deltaY };
-};
-
-/**
- * I <3 Quirksmode.org:
- * http://www.quirksmode.org/js/events_properties.html
- */
-AbstractEvent.isNativeClickEventRightClick = function(nativeEvent) {
-  return nativeEvent.which ? nativeEvent.which === 3 :
-    nativeEvent.button ? nativeEvent.button === 2 :
-    false;
-};
-
-AbstractEvent.normalizePointerData = function(nativeEvent) {
-  return {
-    globalX: AbstractEvent.eventPageX(nativeEvent),
-    globalY: AbstractEvent.eventPageY(nativeEvent),
-    rightMouseButton:
-      AbstractEvent.isNativeClickEventRightClick(nativeEvent)
-  };
-};
-
-AbstractEvent.normalizeDragEventData =
-  function(nativeEvent, globalX, globalY, startX, startY) {
-    return {
-      globalX: globalX,
-      globalY: globalY,
-      startX: startX,
-      startY: startY
-    };
-  };
-
-/**
- * Warning: It is possible to move your finger on a touch surface, yet not
- * effect the `eventPageX/Y` because the touch had caused a scroll that
- * compensated for your movement. To track movements across the page, prevent
- * default to avoid scrolling, and control scrolling in javascript.
- */
-
-/**
- * Gets the exact position of a touch/mouse event on the page with respect to
- * the document body. The only reason why this method is needed instead of using
- * `TouchEventUtils.extractSingleTouch` is to support IE8-. Mouse events in all
- * browsers except IE8- contain a pageY. IE8 and below require clientY
- * computation:
- *
- * @param {Event} nativeEvent Native event, possibly touch or mouse.
- * @return {number} Coordinate with respect to document body.
- */
-AbstractEvent.eventPageY = function(nativeEvent) {
-  var singleTouch = TouchEventUtils.extractSingleTouch(nativeEvent);
-  if (singleTouch) {
-    return singleTouch.pageY;
-  } else if (typeof nativeEvent.pageY !== 'undefined') {
-    return nativeEvent.pageY;
-  } else {
-    return nativeEvent.clientY + BrowserEnv.currentPageScrollTop;
-  }
-};
-
-/**
- * @see `AbstractEvent.eventPageY`.
- *
- * @param {Event} nativeEvent Native event, possibly touch or mouse.
- * @return {number} Coordinate with respect to document body.
- */
-AbstractEvent.eventPageX = function(nativeEvent) {
-  var singleTouch = TouchEventUtils.extractSingleTouch(nativeEvent);
-  if (singleTouch) {
-    return singleTouch.pageX;
-  } else if (typeof nativeEvent.pageX !== 'undefined') {
-    return nativeEvent.pageX;
-  } else {
-    return nativeEvent.clientX + BrowserEnv.currentPageScrollLeft;
-  }
-};
-
-/**
- * A semantic API around cloning an event for use in another event loop. We
- * clear out all dispatched `AbstractEvent`s after each event loop, adding them
- * back into the pool. This allows a way to hold onto a reference that won't be
- * added back into the pool. Please note that `AbstractEvent.nativeEvent` is
- * *not* cloned and you will run into problems in IE if you assume that it will
- * be! The moral of that story is to always normalize any data you need into the
- * `.data` field. The data field is not cloned either, but there won't be any
- * issues related to use of `.data` in a future event cycle so long as no part
- * of your application mutates it. We don't clone the private fields because
- * your application should never be accessing them.
- *
- * - TODO: In __DEV__ when "releasing" events, don't put them back into the
- *   pool. Instead add ES5 getters on all their fields that throw errors so you
- *   can detect any application that's hanging onto events and reusing them.
- *   In prod - we can put them back into the pool for reuse.
- */
-AbstractEvent.persistentCloneOf = function(abstractEvent) {
-  if (true) {
-    throwIf(!(abstractEvent instanceof AbstractEvent), CLONE_TYPE_ERR);
-  }
-  return new AbstractEvent(
-    abstractEvent.type,
-    abstractEvent.abstractTargetID,
-    abstractEvent.originatingTopLevelEventType,
-    abstractEvent.nativeEvent,
-    abstractEvent.data,
-    abstractEvent.target
-  );
-};
-
-module.exports = AbstractEvent;
-
diff --git a/React/AnalyticsEventPluginFactory.js b/React/AnalyticsEventPluginFactory.js
deleted file mode 100644
index 13594aba80..0000000000
--- a/React/AnalyticsEventPluginFactory.js
+++ /dev/null
@@ -1,225 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule AnalyticsEventPluginFactory
- *
- * This module provides a factory method to create the AnalyticsEventPlugin that
- * can be used to track the usage of React components that are of interest to
- * the user.
- *
- * In order to enable a component for analytics tracking, you need to specify
- * two additional attributes to the component when you describe the structure of
- * your component in the render() method:
- *
- * 1. 'data-analytics-id': This represents a unique ID that the analytics module
- *     will use to identify this component in all the analytics data. Note that
- *     this is independent of the ref or the DOM id of the element. Over the
- *     lifetime of the product, even if the component id or ref needs to be
- *     changed, as long as you can ensure the analytics ID doesnt change, the
- *     historical data can be correlated. Also note that React does NOT do
- *     anything to guarantee or enforce uniqueness of this ID. If its not unique
- *     the analytics data reported will be incorrect.
- *
- * 2. 'data-analytics-events': This is a comma separated list of DOM events that
- *     you want analytics on. React currently supports tracking only on a
- *     distinct set of events (See topLevelTypesToAnalyticsEvent).
- *     If the list contains an event that React does not recognize for analytics
- *     tracking, in __DEV__, an error will be thrown. Note that it is case
- *     sensitive and space sensitive.
- *
- * By default the AnalyticsEventPlugin is NOT enabled in React. To use it, you
- * need to create the plugin using the factory method and add it to the list of
- * Plugins maintained in the EventPluginHub before your component is rendered.
- * As creation parameters you can specify two arguments:
- *
- * 1. callback: This is a required parameter. In __DEV__, an error will be
- *    thrown if this param is missing. The callback will be called with the
- *    analyticsData as an argument. The analyticsData will contain one property
- *    per every React component, identified by its data-analytics-id. The value
- *    of this property will be an object containing properties corresponding to
- *    each of the comma separated events specified in data-analytics-events.
- *
- *    For example, if you have:
- *    <Button ...
- *      data-analytics-id="createButton"
- *      data-analytics-events="click"
- *    />
- *    and
- *    <TextBox ...
- *      data-analytics-id="disclaimerBox"
- *      data-analytics-events="focus,scroll"
- *    />
- *    analyticsData will be something like:
- *    '{"createButton":{"click":50}, "disclaimerBox":{"focus":15, "scroll":5}}'
- *
- *    DO NOT mutate the data that you get in the callback. Mutating it will lead
- *    to errors and unstable behavior.
- *
- *    The React component will be included for analytics as long as some user
- *    interaction has happened with that component. If no user interaction has
- *    happened with any of the components tracked for analytics, the callback
- *    will not be called.
- *
- * 2. interval (in milliseconds): This is an optional parameter to specify the
- *    interval at which the callback needs to be called. It needs to be greater
- *    than the 2 minutes (which is the default value if this parameter is not
- *    specified or a value less than 2 minutes is specified)
- *
- * Please refer to the unit tests AnalyticsEventPlugin-test.js for details on
- * usage.
- */
-
-"use strict";
-
-var ExecutionEnvironment = require("./ExecutionEnvironment");
-
-var emptyFunction = require("./emptyFunction");
-var invariant = require("./invariant");
-var topLevelTypes = require("./EventConstants").topLevelTypes;
-
-var ANALYTICS_ID = 'data-analytics-id';
-var ANALYTICS_EVENTS = 'data-analytics-events';
-var DEFAULT_INTERVAL_MS = 2 * 60 * 1000; // 2 minutes
-
-var analyticsData = {};
-
-// List of topLevel event types that React supports for analytics tracking
-var topLevelTypesToAnalyticsEvent = {
-  topClick:       'click',
-  topDoubleClick: 'doubleClick',
-  topMouseWheel:  'mouseWheel',
-  topTouchStart:  'touchStart',
-  topTouchEnd:    'touchEnd',
-  topTouchMove:   'touchMove',
-  topTouchCancel: 'touchCancel',
-  topKeyUp:       'keyUp',
-  topKeyPress:    'keyPress',
-  topKeyDown:     'keyDown',
-  topFocus:       'focus',
-  topBlur:        'blur',
-  topScroll:      'scroll',
-  topChange:      'change'
-};
-
-if (true) {
-  var analyticsEventNameToTopLevelType = {
-    'click':        topLevelTypes.topClick,
-    'doubleClick':  topLevelTypes.topDoubleClick,
-    'mouseWheel':   topLevelTypes.topMouseWheel,
-    'touchStart':   topLevelTypes.topTouchStart,
-    'touchEnd':     topLevelTypes.topTouchEnd,
-    'touchMove':    topLevelTypes.topTouchMove,
-    'touchCancel':  topLevelTypes.topTouchCancel,
-    'keyUp':        topLevelTypes.topKeyUp,
-    'keyPress':     topLevelTypes.topKeyPress,
-    'keyDown':      topLevelTypes.topKeyDown,
-    'focus':        topLevelTypes.topFocus,
-    'blur':         topLevelTypes.topBlur,
-    'scroll':       topLevelTypes.topScroll,
-    'change':       topLevelTypes.topChange
-  };
-}
-
-/**
- * This plugin does not really extract any abstract events. Rather it just looks
- * at the top level event and bumps up counters as appropriate
- *
- * @see EventPluginHub.extractAbstractEvents
- */
-function extractAbstractEvents(
-    topLevelType,
-    nativeEvent,
-    renderedTargetID,
-    renderedTarget) {
-  var currentEvent = topLevelTypesToAnalyticsEvent[topLevelType];
-  if (!currentEvent || !renderedTarget || !renderedTarget.attributes) {
-    return null;
-  }
-
-  var analyticsIDAttribute = renderedTarget.attributes[ANALYTICS_ID];
-  var analyticsEventsAttribute = renderedTarget.attributes[ANALYTICS_EVENTS];
-  if(!analyticsIDAttribute || !analyticsEventsAttribute) {
-    return null;
-  }
-
-  var analyticsEventsArr = analyticsEventsAttribute.value.split(",");
-  var analyticsID = analyticsIDAttribute.value;
-  if (!analyticsData[analyticsID]) {
-    initAnalyticsDataForID(analyticsID, analyticsEventsArr);
-  }
-
-  if (analyticsEventsArr.indexOf(currentEvent) !== -1) {
-    analyticsData[analyticsID][currentEvent]++;
-  }
-
-  return null;
-}
-
-/**
- * Initialize the analytics data for a specific element identified by the
- * analyticsID - Create an entry in the analyticsData object for the element and
- * initialize all counters for that element to 0.
- */
-function initAnalyticsDataForID(analyticsID, analyticsEventsArr) {
-  analyticsData[analyticsID] = {};
-  analyticsEventsArr.forEach(function(analyticsEvent) {
-    if (true) {
-      invariant(
-        analyticsEventNameToTopLevelType[analyticsEvent],
-        'Invalid analyticsEvent:%s for analyticsID:%s',
-        analyticsEvent,
-        analyticsID
-      );
-    }
-    analyticsData[analyticsID][analyticsEvent] = 0;
-  });
-}
-
-/**
- * Returns the analytics event plugin given the callback that needs to be
- * invoked for reporting analytics and the interval at which the callback needs
- * to be invoked. This interval has to be atleast DEFAULT_INTERVAL_MS.
- */
-var createAnalyticsPlugin = function(cb, interval) {
-  invariant(
-    ExecutionEnvironment.canUseDOM,
-    'createAnalyticsPlugin(...): The DOM is not supported in the execution ' +
-    'environment.'
-  );
-
-  if (true) {
-    invariant(cb, 'createAnalyticsPlugin(...): You must provide a callback.');
-  }
-  cb = cb || emptyFunction;
-
-  setInterval(
-    function() {
-      if (Object.keys(analyticsData).length) {
-        // Invoke the callback with a clone of analyticsData, otherwise our
-        // analyticsData will be dirtied by user changes
-        cb(analyticsData);
-      }
-    },
-    interval > DEFAULT_INTERVAL_MS ? interval : DEFAULT_INTERVAL_MS
-  );
-
-  return {extractAbstractEvents: extractAbstractEvents};
-};
-
-var AnalyticsEventPluginFactory = {
-  createAnalyticsPlugin: createAnalyticsPlugin
-};
-
-module.exports = AnalyticsEventPluginFactory;
diff --git a/React/BrowserEnv.js b/React/BrowserEnv.js
deleted file mode 100644
index 53937a4ada..0000000000
--- a/React/BrowserEnv.js
+++ /dev/null
@@ -1,36 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule BrowserEnv
- */
-
-"use strict";
-
-/**
- * A place to share/cache browser/chrome level computations.
- */
-var BrowserEnv = {
-  currentScrollLeft: 0,
-  currentScrollTop: 0,
-  browserInfo: null,
-  refreshAuthoritativeScrollValues: function() {
-    BrowserEnv.currentScrollLeft =
-      document.body.scrollLeft + document.documentElement.scrollLeft;
-    BrowserEnv.currentScrollTop =
-      document.body.scrollTop + document.documentElement.scrollTop;
-  }
-};
-
-module.exports = BrowserEnv;
diff --git a/React/CSSProperty.js b/React/CSSProperty.js
deleted file mode 100644
index 389fccf3e7..0000000000
--- a/React/CSSProperty.js
+++ /dev/null
@@ -1,38 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule CSSProperty
- */
-
-"use strict";
-
-/**
- * CSS properties for which we do not append "px".
- */
-var isNumber = {
-  fillOpacity: true,
-  fontWeight: true,
-  opacity: true,
-  orphans: true,
-  textDecoration: true,
-  zIndex: true,
-  zoom: true
-};
-
-var CSSProperty = {
-  isNumber: isNumber
-};
-
-module.exports = CSSProperty;
diff --git a/React/CSSPropertyOperations.js b/React/CSSPropertyOperations.js
deleted file mode 100644
index 54143d5ba6..0000000000
--- a/React/CSSPropertyOperations.js
+++ /dev/null
@@ -1,81 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule CSSPropertyOperations
- * @typechecks
- */
-
-"use strict";
-
-var dangerousStyleValue = require("./dangerousStyleValue");
-var escapeTextForBrowser = require("./escapeTextForBrowser");
-var hyphenate = require("./hyphenate");
-var memoizeStringOnly = require("./memoizeStringOnly");
-
-var processStyleName = memoizeStringOnly(function(styleName) {
-  return escapeTextForBrowser(hyphenate(styleName));
-});
-
-/**
- * Operations for dealing with CSS properties.
- */
-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.
-   *
-   * @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 (typeof styleValue !== 'undefined') {
-        serialized += processStyleName(styleName) + ':';
-        serialized += dangerousStyleValue(styleName, styleValue) + ';';
-      }
-    }
-    return serialized;
-  },
-
-  /**
-   * Sets the value for multiple styles on a node.
-   *
-   * @param {DOMElement} node
-   * @param {object} styles
-   */
-  setValueForStyles: function(node, styles) {
-    var style = node.style;
-    for (var styleName in styles) {
-      if (!styles.hasOwnProperty(styleName)) {
-        continue;
-      }
-      var styleValue = styles[styleName];
-      style[styleName] = dangerousStyleValue(styleName, styleValue);
-    }
-  }
-
-};
-
-module.exports = CSSPropertyOperations;
diff --git a/React/CallbackRegistry.js b/React/CallbackRegistry.js
deleted file mode 100644
index 4d157653bd..0000000000
--- a/React/CallbackRegistry.js
+++ /dev/null
@@ -1,72 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule CallbackRegistry
- */
-
-"use strict";
-
-var listenerBank = {};
-
-/**
- * Stores "listeners" by `registrationName`/`id`. There should be at most one
- * "listener" per `registrationName/id` in the `listenerBank`.
- * Access listeners via `listenerBank[registrationName][id]`
- *
- * @constructor CallbackRegistry
- */
-var CallbackRegistry = {
-
-  /**
-   * Stores `listener` at `listenerBank[registrationName][id]. Is idempotent.
-   * @param {string} domID The id of the DOM node.
-   * @param {string} registrationName The name of listener (`onClick` etc).
-   * @param {Function} listener The callback to to store.
-   */
-  putListener: function(id, registrationName, listener) {
-    var bankForRegistrationName =
-      listenerBank[registrationName] || (listenerBank[registrationName] = {});
-    bankForRegistrationName[id] = listener;
-  },
-
-  /**
-   * @param {string} id.
-   * @param {string} registrationName Name of registration (`onClick` etc).
-   * @return {Function?} The Listener
-   */
-  getListener: function(id, registrationName) {
-    var bankForRegistrationName = listenerBank[registrationName];
-    return bankForRegistrationName && bankForRegistrationName[id];
-  },
-
-  /**
-   * Deletes the listener from the registration bank.
-   * @param {string} id
-   * @param {string} registrationName (`onClick` etc).
-   */
-  deleteListener: function(id, registrationName) {
-    var bankForRegistrationName = listenerBank[registrationName];
-    if (bankForRegistrationName) {
-      delete bankForRegistrationName[id];
-    }
-  },
-
-  // This is needed for tests only. Do not use in real life
-  __purge: function() {
-    listenerBank = {};
-  }
-};
-
-module.exports = CallbackRegistry;
diff --git a/React/DOMChildrenOperations.js b/React/DOMChildrenOperations.js
deleted file mode 100644
index 344e59427b..0000000000
--- a/React/DOMChildrenOperations.js
+++ /dev/null
@@ -1,146 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule DOMChildrenOperations
- */
-
-"use strict";
-
-var Danger = require("./Danger");
-
-var insertNodeAt = require("./insertNodeAt");
-var keyOf = require("./keyOf");
-var throwIf = require("./throwIf");
-
-var NON_INCREASING_OPERATIONS;
-if (true) {
-  NON_INCREASING_OPERATIONS =
-    'DOM child management operations must be provided in order ' +
-    'of increasing destination index. This is likely an issue with ' +
-    'the core framework.';
-}
-
-var MOVE_NODE_AT_ORIG_INDEX = keyOf({moveFrom: null});
-var INSERT_MARKUP = keyOf({insertMarkup: null});
-var REMOVE_AT = keyOf({removeAt: null});
-
-/**
- * In order to carry out movement of DOM nodes without knowing their IDs, we
- * have to first store knowledge about nodes' original indices before beginning
- * to carry out the sequence of operations. Once we begin the sequence, the DOM
- * indices in future instructions are no longer valid.
- *
- * @param {Element} parent Parent DOM node.
- * @param {Object} childOperations Description of child operations.
- * @returns {Array?} Sparse array containing elements by their current index in
- * the DOM.
- */
-var _getNodesByOriginalIndex = function(parent, childOperations) {
-  var nodesByOriginalIndex; // Sparse array.
-  var childOperation;
-  var origIndex;
-  for (var i = 0; i < childOperations.length; i++) {
-    childOperation = childOperations[i];
-    if (MOVE_NODE_AT_ORIG_INDEX in childOperation) {
-      nodesByOriginalIndex = nodesByOriginalIndex || [];
-      origIndex = childOperation.moveFrom;
-      nodesByOriginalIndex[origIndex] = parent.childNodes[origIndex];
-    } else if (REMOVE_AT in childOperation) {
-      nodesByOriginalIndex = nodesByOriginalIndex || [];
-      origIndex = childOperation.removeAt;
-      nodesByOriginalIndex[origIndex] = parent.childNodes[origIndex];
-    }
-  }
-  return nodesByOriginalIndex;
-};
-
-/**
- * Removes DOM elements from their parent, or moved.
- * @param {Element} parent Parent DOM node.
- * @param {Array} nodesByOriginalIndex Child nodes by their original index
- * (potentially sparse.)
- */
-var _removeChildrenByOriginalIndex = function(parent, nodesByOriginalIndex) {
-  for (var j = 0; j < nodesByOriginalIndex.length; j++) {
-    var nodeToRemove = nodesByOriginalIndex[j];
-    if (nodeToRemove) {     // We used a sparse array.
-      parent.removeChild(nodesByOriginalIndex[j]);
-    }
-  }
-};
-
-/**
- * Once all nodes that will be removed or moved - are removed from the parent
- * node, we can begin the process of placing nodes into their final locations.
- * We must perform all operations in the order of the final DOM index -
- * otherwise, we couldn't count on the fact that an insertion at index X, will
- * remain at index X. This will iterate through the child operations, adding
- * content where needed, skip over removals (they've already been removed) and
- * insert "moved" Elements that were previously removed. The "moved" elements
- * are only temporarily removed from the parent, so that index calculations can
- * be manageable and perform well in the cases that matter.
- */
-var _placeNodesAtDestination =
-  function(parent, childOperations, nodesByOriginalIndex) {
-    var origNode;
-    var finalIndex;
-    var lastFinalIndex = -1;
-    var childOperation;
-    for (var k = 0; k < childOperations.length; k++) {
-      childOperation = childOperations[k];
-      if (MOVE_NODE_AT_ORIG_INDEX in childOperation) {
-        origNode = nodesByOriginalIndex[childOperation.moveFrom];
-        finalIndex = childOperation.finalIndex;
-        insertNodeAt(parent, origNode, finalIndex);
-        if (true) {
-          throwIf(finalIndex <= lastFinalIndex, NON_INCREASING_OPERATIONS);
-          lastFinalIndex = finalIndex;
-        }
-      } else if (REMOVE_AT in childOperation) {
-      } else if (INSERT_MARKUP in childOperation) {
-        finalIndex = childOperation.finalIndex;
-        var markup = childOperation.insertMarkup;
-        Danger.dangerouslyInsertMarkupAt(parent, markup, finalIndex);
-        if (true) {
-          throwIf(finalIndex <= lastFinalIndex, NON_INCREASING_OPERATIONS);
-          lastFinalIndex = finalIndex;
-        }
-      }
-    }
-  };
-
-var manageChildren = function(parent, childOperations) {
-  var nodesByOriginalIndex = _getNodesByOriginalIndex(parent, childOperations);
-  if (nodesByOriginalIndex) {
-    _removeChildrenByOriginalIndex(parent, nodesByOriginalIndex);
-  }
-  _placeNodesAtDestination(parent, childOperations, nodesByOriginalIndex);
-};
-
-var setTextNodeValueAtIndex = function(parent, index, val) {
-  parent.childNodes[index].nodeValue = val;
-};
-
-/**
- * Also reexport all of the dangerous functions. It helps to have all dangerous
- * functions located in a single module `Danger`.
- */
-var DOMChildrenOperations = {
-  dangerouslyReplaceNodeWithMarkup: Danger.dangerouslyReplaceNodeWithMarkup,
-  manageChildren: manageChildren,
-  setTextNodeValueAtIndex: setTextNodeValueAtIndex
-};
-
-module.exports = DOMChildrenOperations;
diff --git a/React/DOMProperty.js b/React/DOMProperty.js
deleted file mode 100644
index 8486ac126b..0000000000
--- a/React/DOMProperty.js
+++ /dev/null
@@ -1,263 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule DOMProperty
- * @typechecks
- */
-
-/*jslint bitwise: true */
-
-"use strict";
-
-var invariant = require("./invariant");
-
-/**
- * DOMProperty exports lookup objects that can be used like functions:
- *
- *   > DOMProperty.isValid['id']
- *   true
- *   > DOMProperty.isValid['foobar']
- *   undefined
- *
- * Although this may be confusing, it performs better in general.
- *
- * @see http://jsperf.com/key-exists
- * @see http://jsperf.com/key-missing
- */
-var DOMProperty = {
-
-  /**
-   * Checks whether a property name is a standard property.
-   * @type {Object}
-   */
-  isStandardName: {},
-
-  /**
-   * Mapping from normalized names to attribute names that differ. Attribute
-   * names are used when rendering markup or with `*Attribute()`.
-   * @type {Object}
-   */
-  getAttributeName: {},
-
-  /**
-   * Mapping from normalized names to properties on DOM node instances.
-   * (This includes properties that mutate due to external factors.)
-   * @type {Object}
-   */
-  getPropertyName: {},
-
-  /**
-   * Mapping from normalized names to mutation methods. This will only exist if
-   * mutation cannot be set simply by the property or `setAttribute()`.
-   * @type {Object}
-   */
-  getMutationMethod: {},
-
-  /**
-   * Whether the property must be accessed and mutated as an object property.
-   * @type {Object}
-   */
-  mustUseAttribute: {},
-
-  /**
-   * Whether the property must be accessed and mutated using `*Attribute()`.
-   * (This includes anything that fails `<propName> in <element>`.)
-   * @type {Object}
-   */
-  mustUseProperty: {},
-
-  /**
-   * Whether the property should be removed when set to a falsey value.
-   * @type {Object}
-   */
-  hasBooleanValue: {},
-
-  /**
-   * Whether or not setting a value causes side effects such as triggering
-   * resources to be loaded or text selection changes. We must ensure that
-   * the value is only set if it has changed.
-   * @type {Object}
-   */
-  hasSideEffects: {},
-
-  /**
-   * Checks whether a property name is a custom attribute.
-   * @method
-   */
-  isCustomAttribute: RegExp.prototype.test.bind(
-    /^(data|aria)-[a-z_][a-z\d_.\-]*$/
-  )
-};
-
-/**
- * Mapping from normalized, camelcased property names to a configuration that
- * specifies how the associated DOM property should be accessed or rendered.
- */
-var MustUseAttribute  = 0x1;
-var MustUseProperty   = 0x2;
-var HasBooleanValue   = 0x4;
-var HasSideEffects    = 0x8;
-
-var Properties = {
-  /**
-   * Standard Properties
-   */
-  accept: null,
-  action: null,
-  ajaxify: MustUseAttribute,
-  allowFullScreen: MustUseAttribute | HasBooleanValue,
-  alt: null,
-  autoComplete: null,
-  autoplay: HasBooleanValue,
-  cellPadding: null,
-  cellSpacing: null,
-  checked: MustUseProperty | HasBooleanValue,
-  className: MustUseProperty,
-  colSpan: null,
-  contentEditable: null,
-  controls: MustUseProperty | HasBooleanValue,
-  data: null, // For `<object />` acts as `src`.
-  dir: null,
-  disabled: MustUseProperty | HasBooleanValue,
-  enctype: null,
-  height: null,
-  href: null,
-  htmlFor: null,
-  max: null,
-  method: null,
-  min: null,
-  multiple: MustUseProperty | HasBooleanValue,
-  name: null,
-  poster: null,
-  preload: null,
-  placeholder: null,
-  rel: null,
-  required: HasBooleanValue,
-  role: MustUseAttribute,
-  scrollLeft: MustUseProperty,
-  scrollTop: MustUseProperty,
-  selected: MustUseProperty | HasBooleanValue,
-  spellCheck: null,
-  src: null,
-  step: null,
-  style: null,
-  tabIndex: null,
-  target: null,
-  title: null,
-  type: null,
-  value: MustUseProperty | HasSideEffects,
-  width: null,
-  wmode: MustUseAttribute,
-  /**
-   * SVG Properties
-   */
-  cx: MustUseProperty,
-  cy: MustUseProperty,
-  d: MustUseProperty,
-  fill: MustUseProperty,
-  fx: MustUseProperty,
-  fy: MustUseProperty,
-  points: MustUseProperty,
-  r: MustUseProperty,
-  stroke: MustUseProperty,
-  strokeLinecap: MustUseProperty,
-  strokeWidth: MustUseProperty,
-  transform: MustUseProperty,
-  x: MustUseProperty,
-  x1: MustUseProperty,
-  x2: MustUseProperty,
-  version: MustUseProperty,
-  viewBox: MustUseProperty,
-  y: MustUseProperty,
-  y1: MustUseProperty,
-  y2: MustUseProperty,
-  spreadMethod: MustUseProperty,
-  offset: MustUseProperty,
-  stopColor: MustUseProperty,
-  stopOpacity: MustUseProperty,
-  gradientUnits: MustUseProperty,
-  gradientTransform: MustUseProperty
-};
-
-/**
- * Attribute names not specified use the **lowercase** normalized name.
- */
-var DOMAttributeNames = {
-  className: 'class',
-  htmlFor: 'for',
-  strokeLinecap: 'stroke-linecap',
-  strokeWidth: 'stroke-width',
-  stopColor: 'stop-color',
-  stopOpacity: 'stop-opacity'
-};
-
-/**
- * Property names not specified use the normalized name.
- */
-var DOMPropertyNames = {
-  autoComplete: 'autocomplete',
-  spellCheck: 'spellcheck'
-};
-
-/**
- * Properties that require special mutation methods.
- */
-var DOMMutationMethods = {
-  /**
-   * Setting `className` to null may cause it to be set to the string "null".
-   *
-   * @param {DOMElement} node
-   * @param {*} value
-   */
-  className: function(node, value) {
-    node.className = value || '';
-  }
-};
-
-for (var propName in Properties) {
-  DOMProperty.isStandardName[propName] = true;
-
-  DOMProperty.getAttributeName[propName] =
-    DOMAttributeNames[propName] || propName.toLowerCase();
-
-  DOMProperty.getPropertyName[propName] =
-    DOMPropertyNames[propName] || propName;
-
-  var mutationMethod = DOMMutationMethods[propName];
-  if (mutationMethod) {
-    DOMProperty.getMutationMethod[propName] = mutationMethod;
-  }
-
-  var propConfig = Properties[propName];
-  DOMProperty.mustUseAttribute[propName] = propConfig & MustUseAttribute;
-  DOMProperty.mustUseProperty[propName]  = propConfig & MustUseProperty;
-  DOMProperty.hasBooleanValue[propName]  = propConfig & HasBooleanValue;
-  DOMProperty.hasSideEffects[propName]   = propConfig & HasSideEffects;
-
-  invariant(
-    !DOMProperty.mustUseAttribute[propName] ||
-    !DOMProperty.mustUseProperty[propName],
-    'DOMProperty: Cannot use require using both attribute and property: %s',
-    propName
-  );
-  invariant(
-    DOMProperty.mustUseProperty[propName] ||
-    !DOMProperty.hasSideEffects[propName],
-    'DOMProperty: Properties that have side effects must use property: %s',
-    propName
-  );
-}
-
-module.exports = DOMProperty;
diff --git a/React/DOMPropertyOperations.js b/React/DOMPropertyOperations.js
deleted file mode 100644
index 1e5aa2554f..0000000000
--- a/React/DOMPropertyOperations.js
+++ /dev/null
@@ -1,93 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule DOMPropertyOperations
- * @typechecks
- */
-
-"use strict";
-
-var DOMProperty = require("./DOMProperty");
-
-var escapeTextForBrowser = require("./escapeTextForBrowser");
-var memoizeStringOnly = require("./memoizeStringOnly");
-
-var processAttributeNameAndPrefix = memoizeStringOnly(function(name) {
-  return escapeTextForBrowser(name) + '="';
-});
-
-/**
- * Operations for dealing with DOM properties.
- */
-var DOMPropertyOperations = {
-
-  /**
-   * Creates markup for a property.
-   *
-   * @param {string} name
-   * @param {*} value
-   * @return {?string} Markup string, or null if the property was invalid.
-   */
-  createMarkupForProperty: function(name, value) {
-    if (DOMProperty.isStandardName[name]) {
-      if (value == null || DOMProperty.hasBooleanValue[name] && !value) {
-        return '';
-      }
-      var attributeName = DOMProperty.getAttributeName[name];
-      return processAttributeNameAndPrefix(attributeName) +
-        escapeTextForBrowser(value) + '"';
-    } else if (DOMProperty.isCustomAttribute(name)) {
-      if (value == null) {
-        return '';
-      }
-      return processAttributeNameAndPrefix(name) +
-        escapeTextForBrowser(value) + '"';
-    } else {
-      return null;
-    }
-  },
-
-  /**
-   * Sets the value for a property on a node.
-   *
-   * @param {DOMElement} node
-   * @param {string} name
-   * @param {*} value
-   */
-  setValueForProperty: function(node, name, value) {
-    if (DOMProperty.isStandardName[name]) {
-      var mutationMethod = DOMProperty.getMutationMethod[name];
-      if (mutationMethod) {
-        mutationMethod(node, value);
-      } else if (DOMProperty.mustUseAttribute[name]) {
-        if (DOMProperty.hasBooleanValue[name] && !value) {
-          node.removeAttribute(DOMProperty.getAttributeName[name]);
-        } else {
-          node.setAttribute(DOMProperty.getAttributeName[name], value);
-        }
-      } else {
-        var propName = DOMProperty.getPropertyName[name];
-        if (!DOMProperty.hasSideEffects[name] || node[propName] !== value) {
-          node[propName] = value;
-        }
-      }
-    } else if (DOMProperty.isCustomAttribute(name)) {
-      node.setAttribute(name, value);
-    }
-  }
-
-};
-
-module.exports = DOMPropertyOperations;
diff --git a/React/Danger.js b/React/Danger.js
deleted file mode 100644
index 7193a8f50c..0000000000
--- a/React/Danger.js
+++ /dev/null
@@ -1,158 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule Danger
- */
-
-"use strict";
-
-var ExecutionEnvironment = require("./ExecutionEnvironment");
-
-var throwIf = require("./throwIf");
-
-var DOM_UNSUPPORTED;
-var NO_MARKUP_PARENT;
-var NO_MULTI_MARKUP;
-if (true) {
-  DOM_UNSUPPORTED =
-    'You may not insert markup into the document while you are in a worker ' +
-    'thread. It\'s not you, it\'s me. This is likely the fault of the ' +
-    'framework. Please report this immediately.';
-  NO_MARKUP_PARENT =
-    'You have attempted to inject markup without a suitable parent. This is ' +
-    'likely the fault of the framework - please report immediately.';
-  NO_MULTI_MARKUP =
-    'The framework has attempted to either insert zero or multiple markup ' +
-    'roots into a single location when it should not. This is a serious ' +
-    'error - a fault of the framework - please report immediately.';
-}
-
-var validateMarkupParams;
-if (true) {
-  validateMarkupParams = function(parentNode, markup) {
-    throwIf(!ExecutionEnvironment.canUseDOM, DOM_UNSUPPORTED);
-    throwIf(!parentNode || !parentNode.tagName, NO_MARKUP_PARENT);
-    throwIf(!markup, NO_MULTI_MARKUP);
-  };
-}
-
-var dummies = {};
-
-function getParentDummy(parent) {
-  var parentTag = parent.tagName;
-  return dummies[parentTag] ||
-    (dummies[parentTag] = document.createElement(parentTag));
-}
-
-/**
- * Inserts node after 'after'. If 'after' is null, inserts it after nothing,
- * which is inserting it at the beginning.
- *
- * @param {Element} elem Parent element.
- * @param {Element} insert Element to insert.
- * @param {Element} after Element to insert after.
- * @returns {Element} Element that was inserted.
- */
-function insertNodeAfterNode(elem, insert, after) {
-  if (true) {
-    throwIf(!ExecutionEnvironment.canUseDOM, DOM_UNSUPPORTED);
-  }
-  if (after) {
-    if (after.nextSibling) {
-      return elem.insertBefore(insert, after.nextSibling);
-    } else {
-      return elem.appendChild(insert);
-    }
-  } else {
-    return elem.insertBefore(insert, elem.firstChild);
-  }
-}
-
-/**
- * Slow: Should only be used when it is known there are a few (or one) element
- * in the node list.
- * @param {Element} parentRootDomNode Parent element.
- * @param {HTMLCollection} htmlCollection HTMLCollection to insert.
- * @param {Element} after Element to insert the node list after.
- */
-function inefficientlyInsertHTMLCollectionAfter(
-    parentRootDomNode,
-    htmlCollection,
-    after) {
-
-  if (true) {
-    throwIf(!ExecutionEnvironment.canUseDOM, DOM_UNSUPPORTED);
-  }
-  var ret;
-  var originalLength = htmlCollection.length;
-  // Access htmlCollection[0] because htmlCollection shrinks as we remove items.
-  // `insertNodeAfterNode` will remove items from the htmlCollection.
-  for (var i = 0; i < originalLength; i++) {
-    ret =
-      insertNodeAfterNode(parentRootDomNode, htmlCollection[0], ret || after);
-  }
-}
-
-/**
- * Super-dangerously inserts markup into existing DOM structure. Seriously, you
- * don't want to use this module unless you are building a framework. This
- * requires that the markup that you are inserting represents the root of a
- * tree. We do not support the case where there `markup` represents several
- * roots.
- *
- * @param {Element} parentNode Parent DOM element.
- * @param {string} markup Markup to dangerously insert.
- * @param {number} index Position to insert markup at.
- */
-function dangerouslyInsertMarkupAt(parentNode, markup, index) {
-  if (true) {
-    validateMarkupParams(parentNode, markup);
-  }
-  var parentDummy = getParentDummy(parentNode);
-  parentDummy.innerHTML = markup;
-  var htmlCollection = parentDummy.childNodes;
-  var afterNode = index ? parentNode.childNodes[index - 1] : null;
-  inefficientlyInsertHTMLCollectionAfter(parentNode, htmlCollection, afterNode);
-}
-
-/**
- * Replaces a node with a string of markup at its current position within its
- * parent. `childNode` must be in the document (or at least within a parent
- * node). The string of markup must represent a tree of markup with a single
- * root.
- *
- * @param {Element} childNode Child node to replace.
- * @param {string} markup Markup to dangerously replace child with.
- */
-function dangerouslyReplaceNodeWithMarkup(childNode, markup) {
-  var parentNode = childNode.parentNode;
-  if (true) {
-    validateMarkupParams(parentNode, markup);
-  }
-  var parentDummy = getParentDummy(parentNode);
-  parentDummy.innerHTML = markup;
-  var htmlCollection = parentDummy.childNodes;
-  if (true) {
-    throwIf(htmlCollection.length !== 1, NO_MULTI_MARKUP);
-  }
-  parentNode.replaceChild(htmlCollection[0], childNode);
-}
-
-var Danger = {
-  dangerouslyInsertMarkupAt: dangerouslyInsertMarkupAt,
-  dangerouslyReplaceNodeWithMarkup: dangerouslyReplaceNodeWithMarkup
-};
-
-module.exports = Danger;
diff --git a/React/DefaultEventPluginOrder.js b/React/DefaultEventPluginOrder.js
deleted file mode 100644
index a756078f79..0000000000
--- a/React/DefaultEventPluginOrder.js
+++ /dev/null
@@ -1,40 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule DefaultEventPluginOrder
- */
-
-"use strict";
-
- var keyOf = require("./keyOf");
-
-/**
- * Module that is injectable into `EventPluginHub`, that specifies a
- * deterministic ordering of `EventPlugin`s. A convenient way to reason about
- * plugins, without having to package every one of them. This is better than
- * having plugins be ordered in the same order that they are injected because
- * that ordering would be influenced by the packaging order.
- * `ResponderEventPlugin` must occur before `SimpleEventPlugin` so that
- * preventing default on events is convenient in `SimpleEventPlugin` handlers.
- */
-var DefaultEventPluginOrder = [
-  keyOf({ResponderEventPlugin: null}),
-  keyOf({SimpleEventPlugin: null}),
-  keyOf({TapEventPlugin: null}),
-  keyOf({EnterLeaveEventPlugin: null}),
-  keyOf({AnalyticsEventPlugin: null})
-];
-
-module.exports = DefaultEventPluginOrder;
diff --git a/React/EnterLeaveEventPlugin.js b/React/EnterLeaveEventPlugin.js
deleted file mode 100644
index 98b78c7b6a..0000000000
--- a/React/EnterLeaveEventPlugin.js
+++ /dev/null
@@ -1,102 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule EnterLeaveEventPlugin
- */
-
-"use strict";
-
-var EventPropagators = require("./EventPropagators");
-var ExecutionEnvironment = require("./ExecutionEnvironment");
-var AbstractEvent = require("./AbstractEvent");
-var EventConstants = require("./EventConstants");
-var ReactInstanceHandles = require("./ReactInstanceHandles");
-
-var getDOMNodeID = require("./getDOMNodeID");
-var keyOf = require("./keyOf");
-
-var topLevelTypes = EventConstants.topLevelTypes;
-var getFirstReactDOM = ReactInstanceHandles.getFirstReactDOM;
-
-var abstractEventTypes = {
-  mouseEnter: {registrationName: keyOf({onMouseEnter: null})},
-  mouseLeave: {registrationName: keyOf({onMouseLeave: null})}
-};
-
-/**
- * For almost every interaction we care about, there will be a top level
- * `mouseOver` and `mouseOut` event that occur so we can usually only pay
- * attention to one of the two (we'll pay attention to the `mouseOut` event) to
- * avoid extracting a duplicate event. However, there's one interaction where
- * there will be no `mouseOut` event to rely on - mousing from outside the
- * browser *into* the chrome. We detect this scenario and only in that case, we
- * use the `mouseOver` event.
- *
- * @see EventPluginHub.extractAbstractEvents
- */
-var extractAbstractEvents = function(
-    topLevelType,
-    nativeEvent,
-    renderedTargetID,
-    renderedTarget) {
-
-  if (topLevelType === topLevelTypes.topMouseOver &&
-      (nativeEvent.relatedTarget || nativeEvent.fromElement)) {
-    return;
-  }
-  if (topLevelType !== topLevelTypes.topMouseOut &&
-     topLevelType !== topLevelTypes.topMouseOver){
-    return null;  // Must not be a mouse in or mouse out - ignoring.
-  }
-
-  var to, from;
-  if (topLevelType === topLevelTypes.topMouseOut) {
-    to = getFirstReactDOM(nativeEvent.relatedTarget || nativeEvent.toElement) ||
-      ExecutionEnvironment.global;
-    from = renderedTarget;
-  } else {
-    to = renderedTarget;
-    from = ExecutionEnvironment.global;
-  }
-
-  // Nothing pertains to our managed components.
-  if (from === to ) {
-    return;
-  }
-
-  var fromID = from ? getDOMNodeID(from) : '';
-  var toID = to ? getDOMNodeID(to) : '';
-  var leave = AbstractEvent.getPooled(
-    abstractEventTypes.mouseLeave,
-    fromID,
-    topLevelType,
-    nativeEvent
-  );
-  var enter = AbstractEvent.getPooled(
-    abstractEventTypes.mouseEnter,
-    toID,
-    topLevelType,
-    nativeEvent
-  );
-  EventPropagators.accumulateEnterLeaveDispatches(leave, enter, fromID, toID);
-  return [leave, enter];
-};
-
-var EnterLeaveEventPlugin = {
-  abstractEventTypes: abstractEventTypes,
-  extractAbstractEvents: extractAbstractEvents
-};
-
-module.exports = EnterLeaveEventPlugin;
diff --git a/React/EventConstants.js b/React/EventConstants.js
deleted file mode 100644
index a6fdb6c399..0000000000
--- a/React/EventConstants.js
+++ /dev/null
@@ -1,57 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule EventConstants
- */
-
-"use strict";
-
-var keyMirror = require("./keyMirror");
-
-var PropagationPhases = keyMirror({bubbled: null, captured: null});
-
-/**
- * Types of raw signals from the browser caught at the top level.
- */
-var topLevelTypes = keyMirror({
-  topBlur: null,
-  topChange: null,
-  topClick: null,
-  topDOMCharacterDataModified: null,
-  topDoubleClick: null,
-  topFocus: null,
-  topKeyDown: null,
-  topKeyPress: null,
-  topKeyUp: null,
-  topMouseDown: null,
-  topMouseMove: null,
-  topMouseOut: null,
-  topMouseOver: null,
-  topMouseUp: null,
-  topMouseWheel: null,
-  topScroll: null,
-  topSubmit: null,
-  topTouchCancel: null,
-  topTouchEnd: null,
-  topTouchMove: null,
-  topTouchStart: null
-});
-
-var EventConstants = {
-  topLevelTypes: topLevelTypes,
-  PropagationPhases: PropagationPhases
-};
-
-module.exports = EventConstants;
diff --git a/React/EventListener.js b/React/EventListener.js
deleted file mode 100644
index 19466e4209..0000000000
--- a/React/EventListener.js
+++ /dev/null
@@ -1,59 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule EventListener
- */
-
-/**
- * Upstream version of event listener. Does not take into account specific
- * nature of platform.
- */
-var EventListener = {
-  /**
-   * Listens to bubbled events on a DOM node.
-   *
-   * @param {Element} el DOM element to register listener on.
-   * @param {string} handlerBaseName 'click'/'mouseover'
-   * @param {Function!} cb Callback function
-   */
-  listen: function(el, handlerBaseName, cb) {
-    if (el.addEventListener) {
-      el.addEventListener(handlerBaseName, cb, false);
-    } else if (el.attachEvent) {
-      el.attachEvent('on' + handlerBaseName, cb);
-    }
-  },
-
-  /**
-   * Listens to captured events on a DOM node.
-   *
-   * @see `EventListener.listen` for params.
-   * @throws Exception if addEventListener is not supported.
-   */
-  capture: function(el, handlerBaseName, cb) {
-    if (!el.addEventListener) {
-      console.error(
-        'You are attempting to use addEventlistener ' +
-        'in a browser that does not support it support it.' +
-        'This likely means that you will not receive events that ' +
-        'your application relies on (such as scroll).');
-      return;
-    } else {
-      el.addEventListener(handlerBaseName, cb, true);
-    }
-  }
-};
-
-module.exports = EventListener;
diff --git a/React/EventPluginHub.js b/React/EventPluginHub.js
deleted file mode 100644
index afddc55491..0000000000
--- a/React/EventPluginHub.js
+++ /dev/null
@@ -1,324 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule EventPluginHub
- */
-
-"use strict";
-
-var AbstractEvent = require("./AbstractEvent");
-var CallbackRegistry = require("./CallbackRegistry");
-var EventPluginUtils = require("./EventPluginUtils");
-var EventPropagators = require("./EventPropagators");
-var ExecutionEnvironment = require("./ExecutionEnvironment");
-
-var accumulate = require("./accumulate");
-var forEachAccumulated = require("./forEachAccumulated");
-var keyMirror = require("./keyMirror");
-var merge = require("./merge");
-var throwIf = require("./throwIf");
-
-var deleteListener = CallbackRegistry.deleteListener;
-
-var ERRORS = keyMirror({
-  DOUBLE_REGISTER: null,
-  DOUBLE_ENQUEUE: null,
-  DEPENDENCY_ERROR: null
-});
-
-if (true) {
-  ERRORS.DOUBLE_REGISTER =
-    'You\'ve included an event plugin that extracts an ' +
-    'event type with the exact same or identity as an event that ' +
-    'had previously been injected - or, one of the registration names ' +
-    'used by an plugin has already been used.';
-  ERRORS.DOUBLE_ENQUEUE =
-    'During the processing of events, more events were enqueued. This ' +
-    'is strange and should not happen. Please report immediately. ';
-  ERRORS.DEPENDENCY_ERROR =
-    'You have either attempted to load an event plugin that has no ' +
-    'entry in EventPluginOrder, or have attempted to extract events ' +
-    'when some critical dependencies have not yet been injected.';
-}
-
-
-/**
- * EventPluginHub: To see a diagram and explanation of the overall architecture
- * of the plugin hub system, @see ReactEvents.js
- */
-
-/**
- * Injected Dependencies:
- */
-var injection = {
-  /**
-   * [required] Dependency of `EventPropagators`.
-   */
-  injectInstanceHandle: function(InjectedInstanceHandle) {
-    EventPropagators.injection.injectInstanceHandle(InjectedInstanceHandle);
-  },
-
-  /**
-   * `EventPluginOrder`: [optional] Provides deterministic ordering of
-   * `EventPlugin`s. Ordering decoupled from the injection of actual
-   * plugins so that there is always a deterministic and permanent ordering
-   * regardless of the plugins that happen to become packaged, or applications
-   * that happen to inject on-the-fly event plugins.
-   */
-  EventPluginOrder: null,
-  injectEventPluginOrder: function(InjectedEventPluginOrder) {
-    injection.EventPluginOrder = InjectedEventPluginOrder;
-    injection._recomputePluginsList();
-  },
-
-  /**
-   * `EventPlugins`: [optional][lazy-loadable] Plugins that must be listed in
-   * the `EventPluginOrder` injected dependency. The list of plugins may grow as
-   * custom plugins are injected into the system at page as part of the
-   * initialization process, or even after the initialization process (on-the-
-   * fly). Plugins injected into the hub have an opportunity to infer abstract
-   * events when top level events are streamed through the `EventPluginHub`.
-   */
-  plugins: [],
-  injectEventPluginsByName: function(pluginsByName) {
-    injection.pluginsByName = merge(injection.pluginsByName, pluginsByName);
-    injection._recomputePluginsList();
-  },
-
-  /**
-   * A reference of all injected plugins by their name. Both plugins and
-   * `EventPluginOrder` can be injected on-the-fly. Any time either dependency
-   * is (re)injected, the resulting list of plugins in correct order is
-   * recomputed.
-   */
-  pluginsByName: {},
-  _recomputePluginsList: function() {
-    var injectPluginByName = function(name, PluginModule) {
-      var pluginIndex = injection.EventPluginOrder.indexOf(name);
-      throwIf(pluginIndex === -1, ERRORS.DEPENDENCY_ERROR + name);
-      if (!injection.plugins[pluginIndex]) {
-        injection.plugins[pluginIndex] = PluginModule;
-        for (var eventName in PluginModule.abstractEventTypes) {
-          var eventType = PluginModule.abstractEventTypes[eventName];
-          recordAllRegistrationNames(eventType, PluginModule);
-        }
-      }
-    };
-    if (injection.EventPluginOrder) {  // Else, do when plugin order injected
-      var injectedPluginsByName = injection.pluginsByName;
-      for (var name in injectedPluginsByName) {
-        injectPluginByName(name, injectedPluginsByName[name]);
-      }
-    }
-  }
-};
-
-
-/**
- * `renderedTarget`: We'll refer to the concept of a "rendered target". Any
- * framework code that uses the `EventPluginHub` will stream events to the
- * `EventPluginHub`. In order for registered plugins to make sense of the native
- * events, it helps to allow plugins to not only have access to the native
- * `Event` object but also the notion of a "rendered target", which is the
- * conceptual target `Element` of the `Event` that the framework (user of
- * `EventPluginHub`) deems as being the "important" target.
- */
-/**
- * Keeps track of all valid "registration names" (`onClick` etc). We expose
- * these structures to other modules, who will always see updates that we apply
- * to these structures. They should never have a desire to mutate these.
- */
-var registrationNames = {};
-
-/**
- * This prevents the need for clients to call `Object.keys(registrationNames)`
- * every time they want to loop through the possible registration names.
- */
-var registrationNamesArr = [];
-
-/**
- * Internal queue of events that have accumulated their dispatches and are
- * waiting to have their dispatches executed.
- */
-var abstractEventQueue = [];
-
-/**
- * Records all the registration names that the event plugin makes available
- * to the general event system. These are things like
- * `onClick`/`onClickCapture`.
- */
-function recordAllRegistrationNames(eventType, PluginModule) {
-  var phaseName;
-  var phasedRegistrationNames = eventType.phasedRegistrationNames;
-  if (phasedRegistrationNames) {
-    for (phaseName in phasedRegistrationNames) {
-      if (!phasedRegistrationNames.hasOwnProperty(phaseName)) {
-        continue;
-      }
-      if (true) {
-        throwIf(
-          registrationNames[phasedRegistrationNames[phaseName]],
-          ERRORS.DOUBLE_REGISTER
-        );
-      }
-      registrationNames[phasedRegistrationNames[phaseName]] = PluginModule;
-      registrationNamesArr.push(phasedRegistrationNames[phaseName]);
-    }
-  } else if (eventType.registrationName) {
-    if (true) {
-      throwIf(
-        registrationNames[eventType.registrationName],
-        ERRORS.DOUBLE_REGISTER
-      );
-    }
-    registrationNames[eventType.registrationName] = PluginModule;
-    registrationNamesArr.push(eventType.registrationName);
-  }
-}
-
-/**
- * A hacky way to reverse engineer which event plugin module created an
- * AbstractEvent.
- * @param {AbstractEvent} abstractEvent to look at
- */
-function getPluginModuleForAbstractEvent(abstractEvent) {
-  if (abstractEvent.type.registrationName) {
-    return registrationNames[abstractEvent.type.registrationName];
-  } else {
-    for (var phase in abstractEvent.type.phasedRegistrationNames) {
-      if (!abstractEvent.type.phasedRegistrationNames.hasOwnProperty(phase)) {
-        continue;
-      }
-      var PluginModule = registrationNames[
-        abstractEvent.type.phasedRegistrationNames[phase]
-      ];
-      if (PluginModule) {
-        return PluginModule;
-      }
-    }
-  }
-  return null;
-}
-
-var deleteAllListeners = function(domID) {
-  var ii;
-  for (ii = 0; ii < registrationNamesArr.length; ii++) {
-    deleteListener(domID, registrationNamesArr[ii]);
-  }
-};
-
-/**
- * Accepts the stream of top level native events, and gives every registered
- * plugin an opportunity to extract `AbstractEvent`s with annotated dispatches.
- *
- * @param {Enum} topLevelType Record from `EventConstants`.
- * @param {Event} nativeEvent A Standard Event with fixed `target` property.
- * @param {Element} renderedTarget Element of interest to the framework, usually
- *  the same as `nativeEvent.target` but occasionally an element immediately
- *  above `nativeEvent.target` (the first DOM node recognized as one "rendered"
- *  by the framework at hand.)
- * @param {string} renderedTargetID string ID of `renderedTarget`.
- */
-var extractAbstractEvents =
-  function(topLevelType, nativeEvent, renderedTargetID, renderedTarget) {
-    var abstractEvents;
-    var plugins = injection.plugins;
-    var len = plugins.length;
-    for (var i = 0; i < len; i++) {
-      // Not every plugin in the ordering may be loaded at runtime.
-      var possiblePlugin = plugins[i];
-      var extractedAbstractEvents =
-        possiblePlugin &&
-        possiblePlugin.extractAbstractEvents(
-          topLevelType,
-          nativeEvent,
-          renderedTargetID,
-          renderedTarget
-        );
-      if (extractedAbstractEvents) {
-        abstractEvents = accumulate(abstractEvents, extractedAbstractEvents);
-      }
-    }
-    return abstractEvents;
-  };
-
-var enqueueAbstractEvents = function(abstractEvents) {
-  if (abstractEvents) {
-    abstractEventQueue = accumulate(abstractEventQueue, abstractEvents);
-  }
-};
-
-/**
- * Executes a single abstract event dispatch. Returns a value, but this return
- * value doesn't make much sense when executing dispatches for a list of a
- * events. However, if a plugin executes a single dispatch, mostly bypassing
- * `EventPluginHub`, it can execute dispatches directly and assign special
- * meaning to the return value. So this will return the result of executing the
- * dispatch, though for most use cases, it gets dropped.
- */
-var executeDispatchesAndRelease = function(abstractEvent) {
-  if (abstractEvent) {
-    var PluginModule = getPluginModuleForAbstractEvent(abstractEvent);
-    var pluginExecuteDispatch = PluginModule && PluginModule.executeDispatch;
-    EventPluginUtils.executeDispatchesInOrder(
-      abstractEvent,
-      pluginExecuteDispatch || EventPluginUtils.executeDispatch
-    );
-    AbstractEvent.release(abstractEvent);
-  }
-};
-
-/**
- * Sets `abstractEventQueue` to null before processing it, so that we can tell
- * if in the process of processing events, more were enqueued. We throw if we
- * find that any were enqueued though this use case could be supported in the
- * future. For now, throwing an error as it's something we don't expect to
- * occur.
- */
-var processAbstractEventQueue = function() {
-  var processingAbstractEventQueue = abstractEventQueue;
-  abstractEventQueue = null;
-  forEachAccumulated(processingAbstractEventQueue, executeDispatchesAndRelease);
-  if (true) {
-    throwIf(abstractEventQueue, ERRORS.DOUBLE_ENQUEUE);
-  }
-};
-
-/**
- * Provides a unified interface for an arbitrary and dynamic set of event
- * plugins. Loosely, a hub, where several "event plugins" may act as a single
- * event plugin behind the facade of `EventPluginHub`. Each event plugin injects
- * themselves into the HUB, and will immediately become operable upon injection.
- *
- * @constructor EventPluginHub
- */
-var EventPluginHub = {
-  registrationNames: registrationNames,
-  registrationNamesArr: registrationNamesArr,
-  putListener: CallbackRegistry.putListener,
-  getListener: CallbackRegistry.getListener,
-  deleteAllListeners: deleteAllListeners,
-  extractAbstractEvents: extractAbstractEvents,
-  enqueueAbstractEvents: enqueueAbstractEvents,
-  processAbstractEventQueue: processAbstractEventQueue,
-  injection: injection
-};
-
-
-if (ExecutionEnvironment.canUseDOM) {
-  window.EventPluginHub = EventPluginHub;
-}
-
-module.exports = EventPluginHub;
diff --git a/React/EventPluginUtils.js b/React/EventPluginUtils.js
deleted file mode 100644
index cc3aa2b239..0000000000
--- a/React/EventPluginUtils.js
+++ /dev/null
@@ -1,206 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule EventPluginUtils
- */
-
-"use strict";
-
-var EventConstants = require("./EventConstants");
-var AbstractEvent = require("./AbstractEvent");
-
-var invariant = require("./invariant");
-
-var topLevelTypes = EventConstants.topLevelTypes;
-
-function isEndish(topLevelType) {
-  return topLevelType === topLevelTypes.topMouseUp ||
-         topLevelType === topLevelTypes.topTouchEnd ||
-         topLevelType === topLevelTypes.topTouchCancel;
-}
-
-function isMoveish(topLevelType) {
-  return topLevelType === topLevelTypes.topMouseMove ||
-         topLevelType === topLevelTypes.topTouchMove;
-}
-function isStartish(topLevelType) {
-  return topLevelType === topLevelTypes.topMouseDown ||
-         topLevelType === topLevelTypes.topTouchStart;
-}
-
-function storePageCoordsIn(obj, nativeEvent) {
-  var pageX = AbstractEvent.eventPageX(nativeEvent);
-  var pageY = AbstractEvent.eventPageY(nativeEvent);
-  obj.pageX = pageX;
-  obj.pageY = pageY;
-}
-
-function eventDistance(coords, nativeEvent) {
-  var pageX = AbstractEvent.eventPageX(nativeEvent);
-  var pageY = AbstractEvent.eventPageY(nativeEvent);
-  return Math.pow(
-    Math.pow(pageX - coords.pageX, 2) + Math.pow(pageY - coords.pageY, 2),
-    0.5
-  );
-}
-
-var validateEventDispatches;
-if (true) {
-  validateEventDispatches = function(abstractEvent) {
-    var dispatchListeners = abstractEvent._dispatchListeners;
-    var dispatchIDs = abstractEvent._dispatchIDs;
-
-    var listenersIsArr = Array.isArray(dispatchListeners);
-    var idsIsArr = Array.isArray(dispatchIDs);
-    var IDsLen = idsIsArr ? dispatchIDs.length : dispatchIDs ? 1 : 0;
-    var listenersLen = listenersIsArr ?
-      dispatchListeners.length :
-      dispatchListeners ? 1 : 0;
-
-    invariant(
-      idsIsArr === listenersIsArr && IDsLen === listenersLen,
-      'EventPluginUtils: Invalid `abstractEvent`.'
-    );
-  };
-}
-
-/**
- * Invokes `cb(abstractEvent, listener, id)`. Avoids using call if no scope is
- * provided. The `(listener,id)` pair effectively forms the "dispatch" but are
- * kept separate to conserve memory.
- */
-function forEachEventDispatch(abstractEvent, cb) {
-  var dispatchListeners = abstractEvent._dispatchListeners;
-  var dispatchIDs = abstractEvent._dispatchIDs;
-  if (true) {
-    validateEventDispatches(abstractEvent);
-  }
-  if (Array.isArray(dispatchListeners)) {
-    var i;
-    for (
-      i = 0;
-      i < dispatchListeners.length && !abstractEvent.isPropagationStopped;
-      i++) {
-      // Listeners and IDs are two parallel arrays that are always in sync.
-      cb(abstractEvent, dispatchListeners[i], dispatchIDs[i]);
-    }
-  } else if (dispatchListeners) {
-    cb(abstractEvent, dispatchListeners, dispatchIDs);
-  }
-}
-
-/**
- * Default implementation of PluginModule.executeDispatch().
- * @param {AbstractEvent} AbstractEvent to handle
- * @param {function} Application-level callback
- * @param {string} domID DOM id to pass to the callback.
- */
-function executeDispatch(abstractEvent, listener, domID) {
-  listener(abstractEvent, domID);
-}
-
-/**
- * Standard/simple iteration through an event's collected dispatches.
- */
-function executeDispatchesInOrder(abstractEvent, executeDispatch) {
-  forEachEventDispatch(abstractEvent, executeDispatch);
-  abstractEvent._dispatchListeners = null;
-  abstractEvent._dispatchIDs = null;
-}
-
-/**
- * Standard/simple iteration through an event's collected dispatches, but stops
- * at the first dispatch execution returning true, and returns that id.
- *
- * @returns id of the first dispatch execution who's listener returns true, or
- * null if no listener returned true.
- */
-function executeDispatchesInOrderStopAtTrue(abstractEvent) {
-  var dispatchListeners = abstractEvent._dispatchListeners;
-  var dispatchIDs = abstractEvent._dispatchIDs;
-  if (true) {
-    validateEventDispatches(abstractEvent);
-  }
-  if (Array.isArray(dispatchListeners)) {
-    var i;
-    for (
-      i = 0;
-      i < dispatchListeners.length && !abstractEvent.isPropagationStopped;
-      i++) {
-      // Listeners and IDs are two parallel arrays that are always in sync.
-      if (dispatchListeners[i](abstractEvent, dispatchIDs[i])) {
-        return dispatchIDs[i];
-      }
-    }
-  } else if (dispatchListeners) {
-    if (dispatchListeners(abstractEvent, dispatchIDs)) {
-      return dispatchIDs;
-    }
-  }
-  return null;
-}
-
-/**
- * Execution of a "direct" dispatch - there must be at most one dispatch
- * accumulated on the event or it is considered an error. It doesn't really make
- * sense for an event with multiple dispatches (bubbled) to keep track of the
- * return values at each dispatch execution, but it does tend to make sense when
- * dealing with "direct" dispatches.
- *
- * @returns The return value of executing the single dispatch.
- */
-function executeDirectDispatch(abstractEvent) {
-  if (true) {
-    validateEventDispatches(abstractEvent);
-  }
-  var dispatchListener = abstractEvent._dispatchListeners;
-  var dispatchID = abstractEvent._dispatchIDs;
-  invariant(
-    !Array.isArray(dispatchListener),
-    'executeDirectDispatch(...): Invalid `abstractEvent`.'
-  );
-  var res = dispatchListener ?
-    dispatchListener(abstractEvent, dispatchID) :
-    null;
-  abstractEvent._dispatchListeners = null;
-  abstractEvent._dispatchIDs = null;
-  return res;
-}
-
-/**
- * @param {AbstractEvent} abstractEvent
- * @returns {bool} True iff number of dispatches accumulated is greater than 0.
- */
-function hasDispatches(abstractEvent) {
-  return !!abstractEvent._dispatchListeners;
-}
-
-/**
- * General utilities that are useful in creating custom Event Plugins.
- */
-var EventPluginUtils = {
-  isEndish: isEndish,
-  isMoveish: isMoveish,
-  isStartish: isStartish,
-  storePageCoordsIn: storePageCoordsIn,
-  eventDistance: eventDistance,
-  executeDispatchesInOrder: executeDispatchesInOrder,
-  executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
-  executeDirectDispatch: executeDirectDispatch,
-  hasDispatches: hasDispatches,
-  executeDispatch: executeDispatch
-};
-
-module.exports = EventPluginUtils;
diff --git a/React/EventPropagators.js b/React/EventPropagators.js
deleted file mode 100644
index 48236e7517..0000000000
--- a/React/EventPropagators.js
+++ /dev/null
@@ -1,180 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule EventPropagators
- */
-
-"use strict";
-
-var CallbackRegistry = require("./CallbackRegistry");
-var EventConstants = require("./EventConstants");
-
-var accumulate = require("./accumulate");
-var forEachAccumulated = require("./forEachAccumulated");
-var getListener = CallbackRegistry.getListener;
-var PropagationPhases = EventConstants.PropagationPhases;
-
-/**
- * Injected dependencies:
- */
-
-/**
- * - `InstanceHandle`: [required] Module that performs logical traversals of DOM
- *   hierarchy given ids of the logical DOM elements involved.
- */
-var injection = {
-  InstanceHandle: null,
-  injectInstanceHandle: function(InjectedInstanceHandle) {
-    injection.InstanceHandle = InjectedInstanceHandle;
-    if (true) {
-      injection.validate();
-    }
-  },
-  validate: function() {
-    var invalid = !injection.InstanceHandle||
-      !injection.InstanceHandle.traverseTwoPhase ||
-      !injection.InstanceHandle.traverseEnterLeave;
-    if (invalid) {
-      throw new Error('InstanceHandle not injected before use!');
-    }
-  }
-};
-
-/**
- * Some event types have a notion of different registration names for different
- * "phases" of propagation. This finds listeners by a given phase.
- */
-function listenerAtPhase(id, abstractEvent, propagationPhase) {
-  var registrationName =
-    abstractEvent.type.phasedRegistrationNames[propagationPhase];
-  return getListener(id, registrationName);
-}
-
-/**
- * Tags an `AbstractEvent` with dispatched listeners. Creating this function
- * here, allows us to not have to bind or create functions for each event.
- * Mutating the event's members allows us to not have to create a wrapping
- * "dispatch" object that pairs the event with the listener.
- */
-function accumulateDirectionalDispatches(domID, upwards, abstractEvent) {
-  if (true) {
-    if (!domID) {
-      throw new Error('Dispatching id must not be null');
-    }
-    injection.validate();
-  }
-  var phase = upwards ? PropagationPhases.bubbled : PropagationPhases.captured;
-  var listener = listenerAtPhase(domID, abstractEvent, phase);
-  if (listener) {
-    abstractEvent._dispatchListeners =
-      accumulate(abstractEvent._dispatchListeners, listener);
-    abstractEvent._dispatchIDs = accumulate(abstractEvent._dispatchIDs, domID);
-  }
-}
-
-/**
- * Collect dispatches (must be entirely collected before dispatching - see unit
- * tests). Lazily allocate the array to conserve memory.  We must loop through
- * each event and perform the traversal for each one. We can not perform a
- * single traversal for the entire collection of events because each event may
- * have a different target.
- */
-function accumulateTwoPhaseDispatchesSingle(abstractEvent) {
-  if (abstractEvent && abstractEvent.type.phasedRegistrationNames) {
-    injection.InstanceHandle.traverseTwoPhase(
-      abstractEvent.abstractTargetID,
-      accumulateDirectionalDispatches,
-      abstractEvent
-    );
-  }
-}
-
-
-/**
- * Accumulates without regard to direction, does not look for phased
- * registration names. Same as `accumulateDirectDispatchesSingle` but without
- * requiring that the `abstractTargetID` be the same as the dispatched ID.
- */
-function accumulateDispatches(id, ignoredDirection, abstractEvent) {
-  if (abstractEvent && abstractEvent.type.registrationName) {
-    var listener = getListener(id, abstractEvent.type.registrationName);
-    if (listener) {
-      abstractEvent._dispatchListeners =
-        accumulate(abstractEvent._dispatchListeners, listener);
-      abstractEvent._dispatchIDs = accumulate(abstractEvent._dispatchIDs, id);
-    }
-  }
-}
-
-/**
- * Accumulates dispatches on an `AbstractEvent`, but only for the
- * `abstractTargetID`.
- * @param {AbstractEvent} abstractEvent
- */
-function accumulateDirectDispatchesSingle(abstractEvent) {
-  if (abstractEvent && abstractEvent.type.registrationName) {
-    accumulateDispatches(abstractEvent.abstractTargetID, null, abstractEvent);
-  }
-}
-
-function accumulateTwoPhaseDispatches(abstractEvents) {
-  if (true) {
-    injection.validate();
-  }
-  forEachAccumulated(abstractEvents, accumulateTwoPhaseDispatchesSingle);
-}
-
-function accumulateEnterLeaveDispatches(leave, enter, fromID, toID) {
-  if (true) {
-    injection.validate();
-  }
-  injection.InstanceHandle.traverseEnterLeave(
-    fromID,
-    toID,
-    accumulateDispatches,
-    leave,
-    enter
-  );
-}
-
-
-function accumulateDirectDispatches(abstractEvents) {
-  if (true) {
-    injection.validate();
-  }
-  forEachAccumulated(abstractEvents, accumulateDirectDispatchesSingle);
-}
-
-
-
-/**
- * A small set of propagation patterns, each of which will accept a small amount
- * of information, and generate a set of "dispatch ready event objects" - which
- * are sets of events that have already been annotated with a set of dispatched
- * listener functions/ids. The API is designed this way to discourage these
- * propagation strategies from actually executing the dispatches, since we
- * always want to collect the entire set of dispatches before executing event a
- * single one.
- *
- * @constructor EventPropagators
- */
-var EventPropagators = {
-  accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,
-  accumulateDirectDispatches: accumulateDirectDispatches,
-  accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches,
-  injection: injection
-};
-
-module.exports = EventPropagators;
diff --git a/React/ExecutionEnvironment.js b/React/ExecutionEnvironment.js
deleted file mode 100644
index e1bc6c9c60..0000000000
--- a/React/ExecutionEnvironment.js
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ExecutionEnvironment
- */
-
-/*jslint evil: true */
-
-"use strict";
-
-var canUseDOM = typeof window !== 'undefined';
-
-/**
- * Simple, lightweight module assisting with the detection and context of
- * Worker. Helps avoid circular dependencies and allows code to reason about
- * whether or not they are in a Worker, even if they never include the main
- * `ReactWorker` dependency.
- */
-var ExecutionEnvironment = {
-
-  canUseDOM: canUseDOM,
-
-  canUseWorkers: typeof Worker !== 'undefined',
-
-  isInWorker: !canUseDOM, // For now, this is true - might change in the future.
-
-  global: new Function('return this;')()
-
-};
-
-module.exports = ExecutionEnvironment;
diff --git a/React/ImmutableObject.js b/React/ImmutableObject.js
deleted file mode 100644
index cd6163a005..0000000000
--- a/React/ImmutableObject.js
+++ /dev/null
@@ -1,168 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ImmutableObject
- */
-
-"use strict";
-
-var keyMirror = require("./keyMirror");
-var merge = require("./merge");
-var mergeInto = require("./mergeInto");
-var mergeHelpers = require("./mergeHelpers");
-var throwIf = require("./throwIf");
-
-var checkMergeObjectArgs = mergeHelpers.checkMergeObjectArgs;
-var isTerminal = mergeHelpers.isTerminal;
-
-/**
- * Simple wrapper around javascript key/value objects that provide a dev time
- * guarantee of immutability (assuming all modules that may potentially mutate
- * include a "use strict" declaration). Retaining immutability requires CPU
- * cycles (in order to perform the freeze), but this computation can be avoided
- * in production. The fact that mutation attempts in __DEV__ will be caught,
- * allows us to reasonably assume that mutation on those objects won't even be
- * attempted in production. This means that an object being an instanceof
- * `ImmutableObject` implies that the object may never change.
- *
- * TODO: Require strict mode in source files that use ImmutableObject (lint
- * rule).
- *
- * @class ImmutableObject
- */
-
-var ERRORS;
-var ImmutableObject;
-
-if (true) {
-  ERRORS = {
-    INVALID_MAP_SET_ARG: 'You have attempted to set fields on an object that ' +
-      'is not an instance of ImmutableObject'
-  };
-
-  /**
-   * Constructs an instance of `ImmutableObject`.
-   *
-   * @param {!Object} initMap The initial set of properties.
-   * @constructor
-   */
-  ImmutableObject = function(initMap) {
-    mergeInto(this, initMap);
-    deepFreeze(this, initMap);
-  };
-
-  /**
-   * Objects that are instances of `ImmutableObject` are assumed to be deep
-   * frozen.
-   * @param {!Object} o The object to deep freeze.
-   * @return {!boolean} Whether or not deep freeze is needed.
-   */
-  var shouldRecurseFreeze = function(o) {
-    return (typeof o) === 'object' &&
-        !(o instanceof ImmutableObject) && o !== null;
-  };
-
-  /**
-   * Freezes an object `o` deeply. Invokes `shouldRecurseFreeze` to determine if
-   * further freezing is needed.
-   *
-   * @param {!Object} o The object to freeze.
-   */
-  var deepFreeze = function(o) {
-    var prop;
-    Object.freeze(o); // First freeze the object.
-    for (prop in o) {
-      var field = o[prop];
-      if (o.hasOwnProperty(prop) && shouldRecurseFreeze(field)) {
-        deepFreeze(field);
-      }
-    }
-  };
-
-  /**
-   * Returns a new ImmutableObject that is that is the same as the parameter
-   * `immutableObject` but with the differences specified in `put`.
-   * @param {!ImmutableObject} ImmutableObject The ImmutableObject object to set
-   * fields on.
-   * @param {!Object} put Subset of fields to merge into the returned result.
-   * @return {!ImmutableObject} The result of merging in `put` fields.
-   */
-  ImmutableObject.set = function(immutableObject, put) {
-    throwIf(
-      !(immutableObject instanceof ImmutableObject),
-      ERRORS.INVALID_MAP_SET_ARG
-    );
-    var totalNewFields = merge(immutableObject, put);
-    return new ImmutableObject(totalNewFields);
-  };
-
-}
-
-/**
- * Sugar for `ImmutableObject.set(ImmutableObject, {fieldName: putField})`
- * @see ImmutableObject.set
- */
-ImmutableObject.setField = function(immutableObject, fieldName, putField) {
-  var put = {};
-  put[fieldName] = putField;
-  return ImmutableObject.set(immutableObject, put);
-};
-
-/**
- * Returns a new ImmutableObject that is that is the same as the parameter
- * `immutableObject` but with the differences specified in `put` recursively
- * applied.
- */
-ImmutableObject.setDeep = function(immutableObject, put) {
-  throwIf(
-    !(immutableObject instanceof ImmutableObject),
-    ERRORS.INVALID_MAP_SET_ARG
-  );
-  return _setDeep(immutableObject, put);
-};
-
-function _setDeep(object, put) {
-  checkMergeObjectArgs(object, put);
-  var totalNewFields = {};
-
-  // To maintain the order of the keys, copy the base object's entries first.
-  var keys = Object.keys(object);
-  for (var ii = 0; ii < keys.length; ii++) {
-    var key = keys[ii];
-    if (!put.hasOwnProperty(key)) {
-      totalNewFields[key] = object[key];
-    } else if (isTerminal(object[key]) || isTerminal(put[key])) {
-      totalNewFields[key] = put[key];
-    } else {
-      totalNewFields[key] = _setDeep(object[key], put[key]);
-    }
-  }
-
-  // Apply any new keys that the base object didn't have.
-  var newKeys = Object.keys(put);
-  for (ii = 0; ii < newKeys.length; ii++) {
-    var newKey = newKeys[ii];
-    if (object.hasOwnProperty(newKey)) {
-      continue;
-    }
-    totalNewFields[newKey] = put[newKey];
-  }
-
-  return (object instanceof ImmutableObject || put instanceof ImmutableObject) ?
-    new ImmutableObject(totalNewFields) :
-    totalNewFields;
-}
-
-module.exports = ImmutableObject;
diff --git a/React/NormalizedEventListener.js b/React/NormalizedEventListener.js
deleted file mode 100644
index 3d263a978e..0000000000
--- a/React/NormalizedEventListener.js
+++ /dev/null
@@ -1,88 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule NormalizedEventListener
- */
-
-"use strict";
-
-var EventListener = require("./EventListener");
-
-/**
- * @param {?Event} eventParam Event parameter from an attached listener.
- * @return {Event} Normalized event object.
- * @private
- */
-function normalizeEvent(eventParam) {
-  var normalized = eventParam || window.event;
-  // In some browsers (OLD FF), setting the target throws an error. A good way
-  // to tell if setting the target will throw an error, is to check if the event
-  // has a `target` property. Safari events have a `target` but it's not always
-  // normalized. Even if a `target` property exists, it's good to only set the
-  // target property if we realize that a change will actually take place.
-  var hasTargetProperty = 'target' in normalized;
-  var eventTarget = normalized.target || normalized.srcElement || window;
-  // Safari may fire events on text nodes (Node.TEXT_NODE is 3)
-  // @see http://www.quirksmode.org/js/events_properties.html
-  var textNodeNormalizedTarget =
-    (eventTarget.nodeType === 3) ? eventTarget.parentNode : eventTarget;
-  if (!hasTargetProperty || normalized.target !== textNodeNormalizedTarget) {
-    // Create an object that inherits from the native event so that we can set
-    // `target` on it. (It is read-only and setting it throws in strict mode).
-    normalized = Object.create(normalized);
-    normalized.target = textNodeNormalizedTarget;
-  }
-  return normalized;
-}
-
-function createNormalizedCallback(cb) {
-  return function(unfixedNativeEvent) {
-    cb(normalizeEvent(unfixedNativeEvent));
-  };
-}
-
-var NormalizedEventListener = {
-
-  /**
-   * Listens to bubbled events on a DOM node.
-   *
-   * NOTE: The listener will be invoked with a normalized event object.
-   *
-   * @param {DOMElement} el DOM element to register listener on.
-   * @param {string} handlerBaseName Event name, e.g. "click".
-   * @param {function} cb Callback function.
-   * @public
-   */
-  listen: function(el, handlerBaseName, cb) {
-    EventListener.listen(el, handlerBaseName, createNormalizedCallback(cb));
-  },
-
-  /**
-   * Listens to captured events on a DOM node.
-   *
-   * NOTE: The listener will be invoked with a normalized event object.
-   *
-   * @param {DOMElement} el DOM element to register listener on.
-   * @param {string} handlerBaseName Event name, e.g. "click".
-   * @param {function} cb Callback function.
-   * @public
-   */
-  capture: function(el, handlerBaseName, cb) {
-    EventListener.capture(el, handlerBaseName, createNormalizedCallback(cb));
-  }
-
-};
-
-module.exports = NormalizedEventListener;
diff --git a/React/OrderedMap.js b/React/OrderedMap.js
deleted file mode 100644
index 87981ab35e..0000000000
--- a/React/OrderedMap.js
+++ /dev/null
@@ -1,514 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule OrderedMap
- */
-
-"use strict";
-
-var mixInto = require("./mixInto");
-var throwIf = require("./throwIf");
-
-var PREFIX = 'key:';
-
-var ARRAY_MUST_CB = 'ARRAY_MUST_CB';
-var INVALID_KEY = 'INVALID_KEY';
-var DUPLICATE_KEY = 'DUPLICATE_KEY';
-var OPERATION_ARGS = 'OPERATION_ARGS';
-var RANGE_ARGS = 'RANGE_ARGS';
-var NO_EXIST = 'NO_EXIST';
-
-if (true) {
-  ARRAY_MUST_CB =
-    'If providing an array to an OrderedMap constructor, you must provide ' +
-    'a callback that may determine the uniqueue key for each entry. ' +
-    'The key that you return from the callback should uniquely define that ' +
-    'entity. What is returned from that function must answer the question: ' +
-    '"If you were to shuffle the array of entities, how would you be able to ' +
-    'determine the identity of the Array entry?"';
-  INVALID_KEY =
-    'Key must be non-empty, non-null, string or number';
-  DUPLICATE_KEY =
-    'At creation time, you must extract out IDs that are unique.';
-  OPERATION_ARGS =
-    'Invalid argument type for construction or operation on OrderedMap. ' +
-    'from/merge accepts another OrderedMap. fromArray accepts an Array ' +
-    'and a callback to extract a unique ID.';
-  RANGE_ARGS =
-    'OrderedMap.mapRange requires end of range to be >= start, start to be ' +
-    '>= 0 and end < length.';
-  NO_EXIST =
-    'The requested key does not exist in the OrderedMap';
-}
-
-/**
- * Utility to extract a backing object from an initialization `Array`, allowing
- * the caller to assist in resolving the unique ID for each entry via the
- * `keyExtractor` callback. The `keyExtractor` must extract non-empty strings or
- * numbers.
- * @param {Array<Object!>} arr Array of items.
- * @param {function} keyExtractor Extracts a unique key from each item.
- * @return {Object} Map from unique key to originating value that the key was
- * extracted from.
- * @throws Exception if the initialization array has duplicate extracted keys.
- */
-function extractObjectFromArray(arr, keyExtractor) {
-  var normalizedObj = {};
-  for (var i=0; i < arr.length; i++) {
-    var item = arr[i];
-    var key = keyExtractor(item);
-    validatePublicKey(key);
-    var normalizedKey = PREFIX + key;
-    throwIf(normalizedKey in normalizedObj, DUPLICATE_KEY);
-    normalizedObj[normalizedKey] = item;
-  }
-  return normalizedObj;
-}
-
-/**
- * Utility class for mappings with ordering. This class is to be used in an
- * immutable manner. A `OrderedMap` is very much like the native JavaScript
- * object, where keys map to values via the `get()` function. Also, like the
- * native JavaScript object, there is an ordering associated with the mapping.
- * This class is helpful because it eliminates many of the pitfalls that come
- * with the native JavaScript ordered mappings. Specifically, there are
- * inconsistencies with numeric keys in some JavaScript implementations
- * (enumeration ordering). This class protects against those pitfalls and
- * provides functional utilities for dealing with these `OrderedMap`s.
- *
- * - TODO:
- * - orderedMergeExclusive: Merges mutually exclusive `OrderedMap`s.
- * - mapReverse().
- *
- * @class {OrderedMap}
- * @constructor {OrderedMap}
- * @param {Object} normalizedObj Object that is known to be a defensive copy of
- * caller supplied data. We require a defensive copy to guard against callers
- * mutating.  It is also assumed that the keys of `normalizedObj` have been
- * normalized and do not contain any numeric-appearing strings.
- * @param {number} computedLength The precomputed length of `_normalizedObj`
- * keys.
- * @private
- */
-function OrderedMapImpl(normalizedObj, computedLength) {
-  this._normalizedObj = normalizedObj;
-  this._computedPositions = null;
-  this.length = computedLength;
-}
-
-/**
- * Validates a "public" key - that is, one that the public facing API supplies.
- * The key is then normalized for internal storage. In order to be considered
- * valid, all keys must be non-empty, defined, non-null strings or numbers.
- * Since this already costs a function invocation, will avoid additional call to
- * `throwIf`.
- *
- * @param {string?} key Validates that the key is suitable for use in a
- * `OrderedMap`.
- * @throws Error if key is not appropriate for use in `OrderedMap`.
- */
-function validatePublicKey(key) {
-  var isEmpty = key === '';
-  var correctKeyType = typeof key === 'string' || typeof key === 'number';
-  if (isEmpty || !correctKeyType) {
-    throw new Error(INVALID_KEY);
-  }
-}
-
-/**
- * Validates that arguments to range operations are within the correct limits.
- *
- * @param {number} start Start of range.
- * @param {number} length Length of range.
- * @param {number} actualLen Actual length of range that should not be
- * exceeded.
- * @return {void} description
- */
-function validateRangeIndices(start, length, actualLen) {
-  var startType = typeof start;
-  var lengthType = typeof length;
-  var invalid =
-    startType !== 'number' || lengthType !== 'number' ||
-    length < 0 || start < 0 || start + length > actualLen;
-  if (invalid) {
-    throw new Error(RANGE_ARGS);
-  }
-}
-
-/**
- * Merges two "normalized" objects (objects who's key have been normalized) into
- * a `OrderedMap`.
- *
- * @param {Object} a Object of key value pairs.
- * @param {Object} b Object of key value pairs.
- * @return {OrderedMap} new `OrderedMap` that results in merging `a` and `b`.
- */
-function _fromNormalizedObjects(a, b) {
-  // Second optional, both must be a Plain Old JavaScript Object.
-  var invalidArgs =
-    !a || a.constructor !== Object || (b && b.constructor !== Object);
-  throwIf(invalidArgs, OPERATION_ARGS);
-  var newSet = {};
-  var length = 0;
-  var key;
-  for (key in a) {
-    if (a.hasOwnProperty(key)) {
-      newSet[key] = a[key];
-      length++;
-    }
-  }
-
-  for (key in b) {
-    if (b.hasOwnProperty(key)) {
-      // Increment length if not already added via first object (a)
-      if (!(key in newSet)) {
-        length++;
-      }
-      newSet[key] = b[key];
-    }
-  }
-  return new OrderedMapImpl(newSet, length);
-}
-
-/**
- * Methods for `OrderedMap` instances.
- *
- * @lends OrderedMap.prototype
- * TODO: Make this data structure lazy, unify with LazyArray.
- * TODO: Unify this with ImmutableObject - it is to be used immutably.
- * TODO: If so, consider providing `fromObject` API.
- * TODO: Create faster implementation of merging/mapping from original Array,
- * without having to first create an object - simply for the sake of merging.
- */
-var OrderedMapMethods = {
-
-  /**
-   * Returns whether or not a given key is present in the map.
-   *
-   * @param {string} key Valid string key to lookup membership for.
-   * @return {boolean} Whether or not `key` is a member of the map.
-   * @throws Error if provided known invalid key.
-   */
-  has: function(key) {
-    validatePublicKey(key);
-    var normalizedKey = PREFIX + key;
-    return normalizedKey in this._normalizedObj;
-  },
-
-  /**
-   * Returns the object for a given key, or `undefined` if not present. To
-   * distinguish a undefined entry vs not being in the set, use `has()`.
-   *
-   * @param {string} key String key to lookup the value for.
-   * @return {Object?} Object at key `key`, or undefined if not in map.
-   * @throws Error if provided known invalid key.
-   */
-  get: function(key) {
-    validatePublicKey(key);
-    var normalizedKey = PREFIX + key;
-    return this.has(key) ? this._normalizedObj[normalizedKey] : undefined;
-  },
-
-  /**
-   * Merges, appending new keys to the end of the ordering. Keys in `orderedMap`
-   * that are redundant with `this`, maintain the same ordering index that they
-   * had in `this`.  This is how standard JavaScript object merging would work.
-   * If you wish to prepend a `OrderedMap` to the beginning of another
-   * `OrderedMap` then simply reverse the order of operation. This is the analog
-   * to `merge(x, y)`.
-   *
-   * @param {OrderedMap} orderedMap OrderedMap to merge onto the end.
-   * @return {OrderedMap} New OrderedMap that represents the result of the
-   * merge.
-   */
-  merge: function(orderedMap) {
-    throwIf(!(orderedMap instanceof OrderedMapImpl), OPERATION_ARGS);
-    return _fromNormalizedObjects(
-      this._normalizedObj,
-      orderedMap._normalizedObj
-    );
-  },
-
-  /**
-   * Functional map API. Returns a new `OrderedMap`.
-   *
-   * @param {Function} cb Callback to invoke for each item.
-   * @param {Object?=} context Context to invoke callback from.
-   * @returns {OrderedMap} OrderedMap that results from mapping.
-   */
-  map: function(cb, context) {
-    return this.mapRange(cb, 0, this.length, context);
-  },
-
-  /**
-   * The callback `cb` is invoked with the arguments (item, key,
-   * indexInOriginal).
-   *
-   * @param {Function} cb Determines result for each item.
-   * @param {number} start Start index of map range.
-   * @param {end} end End index of map range.
-   * @param {*!?} context Context of callback invocation.
-   * @return {OrderedMap} OrderedMap resulting from mapping the range.
-   */
-  mapRange: function(cb, start, length, context) {
-    var thisSet = this._normalizedObj;
-    var newSet = {};
-    var i = 0;
-    validateRangeIndices(start, length, this.length);
-    var end = start + length - 1;
-    for (var key in thisSet) {
-      if (thisSet.hasOwnProperty(key)) {
-        if (i >= start) {
-          if (i > end) {
-            break;
-          }
-          var item = thisSet[key];
-          newSet[key] = cb.call(context, item, key.substr(PREFIX.length), i);
-        }
-        i++;
-      }
-    }
-    return new OrderedMapImpl(newSet, length);
-  },
-
-  /**
-   * Function filter API. Returns new `OrderedMap`.
-   *
-   * @param {Function} cb Callback to invoke for each item.
-   * @param {Object?=} context Context to invoke callback from.
-   * @returns {OrderedMap} OrderedMap that results from filtering.
-   */
-  filter: function(cb, context) {
-    return this.filterRange(cb, 0, this.length, context);
-  },
-
-  /**
-   * The callback `cb` is invoked with the arguments (item, key,
-   * indexInOriginal).
-   *
-   * @param {Function} cb Returns true if item should be in result.
-   * @param {number} start Start index of filter range.
-   * @param {number} end End index of map range.
-   * @param {*!?} context Context of callback invocation.
-   * @return {OrderedMap} OrderedMap resulting from filtering the range.
-   */
-  filterRange: function(cb, start, length, context) {
-    var newSet = {};
-    var newSetLength = 0;
-    this.forEachRange(function(item, key, originalIndex) {
-      if (cb.call(context, item, key, originalIndex)) {
-        var normalizedKey = PREFIX + key;
-        newSet[normalizedKey] = item;
-        newSetLength++;
-      }
-    }, start, length);
-    return new OrderedMapImpl(newSet, newSetLength);
-  },
-
-  forEach: function(cb, context) {
-    this.forEachRange(cb, 0, this.length, context);
-  },
-
-  forEachRange: function(cb, start, length, context) {
-    validateRangeIndices(start, length, this.length);
-    var thisSet = this._normalizedObj;
-    var i = 0;
-    var end = start + length - 1;
-    for (var key in thisSet) {
-      if (thisSet.hasOwnProperty(key)) {
-        if (i >= start) {
-          if (i > end) {
-            break;
-          }
-          var item = thisSet[key];
-          cb.call(context, item, key.substr(PREFIX.length), i);
-        }
-        i++;
-      }
-    }
-  },
-
-  /**
-   * Even though `mapRange`/`forEachKeyRange` allow zero length mappings, we'll
-   * impose an additional restriction here that the length of mapping be greater
-   * than zero - the only reason is that there are many ways to express length
-   * zero in terms of two keys and that is confusing.
-   */
-  mapKeyRange: function(cb, startKey, endKey, context) {
-    var startIndex = this.indexOfKey(startKey);
-    var endIndex = this.indexOfKey(endKey);
-    if (endIndex < startIndex) {
-      throw new Error(RANGE_ARGS);
-    }
-    return this.mapRange(cb, startIndex, (endIndex - startIndex) + 1, context);
-  },
-
-  forEachKeyRange: function(cb, startKey, endKey, context) {
-    var startIndex = this.indexOfKey(startKey);
-    var endIndex = this.indexOfKey(endKey);
-    if (endIndex < startIndex) {
-      throw new Error(RANGE_ARGS);
-    }
-    this.forEachRange(cb, startIndex, (endIndex - startIndex) + 1, context);
-  },
-
-  /**
-   * @param {number} pos Index to search for key at.
-   * @return {string|undefined} Either the key at index `pos` or undefined if
-   * not in map.
-   */
-  keyAtIndex: function(pos) {
-    var computedPositions = this._getOrComputePositions();
-    var keyAtPos = computedPositions.keyByIndex[pos];
-    return keyAtPos ? keyAtPos.substr(PREFIX.length) : undefined;
-  },
-
-  /**
-   * @param {string} key String key from which to find the next key.
-   * @return {string|undefined} Either the next key, or undefined if there is no
-   * next key.
-   * @throws Error if `key` is not in this `OrderedMap`.
-   */
-  keyAfter: function(key) {
-    return this.nthKeyAfter(key, 1);
-  },
-
-  /**
-   * @param {string} key String key from which to find the preceding key.
-   * @return {string|undefined} Either the preceding key, or undefined if there
-   * is no preceding.key.
-   * @throws Error if `key` is not in this `OrderedMap`.
-   */
-  keyBefore: function(key) {
-    return this.nthKeyBefore(key, 1);
-  },
-
-  /**
-   * @param {string} key String key from which to find a following key.
-   * @param {number} n Distance to scan forward after `key`.
-   * @return {string|undefined} Either the nth key after `key`, or undefined if
-   * there is no next key.
-   * @throws Error if `key` is not in this `OrderedMap`.
-   */
-  nthKeyAfter: function(key, n) {
-    var curIndex = this.indexOfKey(key);
-    throwIf(curIndex === undefined, NO_EXIST);
-    return this.keyAtIndex(curIndex + n);
-  },
-
-  /**
-   * @param {string} key String key from which to find a preceding key.
-   * @param {number} n Distance to scan backwards before `key`.
-   * @return {string|undefined} Either the nth key before `key`, or undefined if
-   * there is no previous key.
-   * @throws Error if `key` is not in this `OrderedMap`.
-   */
-  nthKeyBefore: function(key, n) {
-    return this.nthKeyAfter(key, -n);
-  },
-
-  /**
-   * @param {string} key Key to find the index of.
-   * @return {number|undefined} Index of the provided key, or `undefined` if the
-   * key is not found.
-   */
-  indexOfKey: function(key) {
-    validatePublicKey(key);
-    var normalizedKey = PREFIX + key;
-    var computedPositions = this._getOrComputePositions();
-    var computedPosition = computedPositions.indexByKey[normalizedKey];
-    // Just writing it this way to make it clear this is intentional.
-    return computedPosition === undefined ? undefined : computedPosition;
-  },
-
-  /**
-   * @return {Array} An ordered array of this object's values.
-   */
-  toArray: function() {
-    var result = [];
-    var thisSet = this._normalizedObj;
-    for (var key in thisSet) {
-      if (thisSet.hasOwnProperty(key)) {
-        result.push(thisSet[key]);
-      }
-    }
-    return result;
-  },
-
-  /**
-   * Finds the key at a given position, or indicates via `undefined` that that
-   * position does not exist in the `OrderedMap`. It is appropriate to return
-   * undefined, indicating that the key doesn't exist in the `OrderedMap`
-   * because `undefined` is not ever a valid `OrderedMap` key.
-   *
-   * @private
-   * @param {number} pos Position for which we're querying the name.
-   * @return {string?} Name of the item at position `pos`, or `undefined` if
-   * there is no item at that position.
-   */
-  _getOrComputePositions: function() {
-    // TODO: Entertain computing this at construction time in some less
-    // performance critical paths.
-    var computedPositions = this._computedPositions;
-    if (!computedPositions) {
-      this._computePositions();
-    }
-    return this._computedPositions;
-  },
-
-  /**
-   * Precomputes the index/key mapping for future lookup. Since `OrderedMap`s
-   * are immutable, there is only ever a need to perform this once.
-   * @private
-   */
-  _computePositions: function() {
-    this._computedPositions = {
-      keyByIndex: {},
-      indexByKey: {}
-    };
-    var keyByIndex = this._computedPositions.keyByIndex;
-    var indexByKey = this._computedPositions.indexByKey;
-    var index = 0;
-    var thisSet = this._normalizedObj;
-    for (var key in thisSet) {
-      if (thisSet.hasOwnProperty(key)) {
-        keyByIndex[index] = key;
-        indexByKey[key] = index;
-        index++;
-      }
-    }
-  }
-};
-
-mixInto(OrderedMapImpl, OrderedMapMethods);
-
-var OrderedMap = {
-  from: function(orderedMap) {
-    var invalidArg = !(orderedMap instanceof OrderedMapImpl);
-    throwIf(invalidArg, OPERATION_ARGS);
-    return _fromNormalizedObjects(orderedMap._normalizedObj, null);
-  },
-
-  fromArray: function(arr, keyExtractor) {
-    throwIf(!Array.isArray(arr), OPERATION_ARGS);
-    throwIf(!keyExtractor, ARRAY_MUST_CB);
-    return new OrderedMapImpl(
-      extractObjectFromArray(arr, keyExtractor),
-      arr.length
-    );
-  }
-};
-
-module.exports = OrderedMap;
diff --git a/React/PooledClass.js b/React/PooledClass.js
deleted file mode 100644
index 3c86897b11..0000000000
--- a/React/PooledClass.js
+++ /dev/null
@@ -1,101 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule PooledClass
- */
-
-"use strict";
-
-/**
- * Static poolers. Several custom versions for each potential number of
- * arguments. A completely generic pooler is easy to implement, but would
- * require accessing the `arguments` object. In each of these, `this` refers to
- * the Class itself, not an instance. If any others are needed, simply add them
- * here, or in their own files.
- */
-var oneArgumentPooler = function(copyFieldsFrom) {
-  var Klass = this;
-  if (Klass.instancePool.length) {
-    var instance = Klass.instancePool.pop();
-    Klass.call(instance, copyFieldsFrom);
-    return instance;
-  } else {
-    return new Klass(copyFieldsFrom);
-  }
-};
-
-var twoArgumentPooler = function(a1, a2) {
-  var Klass = this;
-  if (Klass.instancePool.length) {
-    var instance = Klass.instancePool.pop();
-    Klass.call(instance, a1, a2);
-    return instance;
-  } else {
-    return new Klass(a1, a2);
-  }
-};
-
-var fiveArgumentPooler = function(a1, a2, a3, a4, a5) {
-  var Klass = this;
-  if (Klass.instancePool.length) {
-    var instance = Klass.instancePool.pop();
-    Klass.call(instance, a1, a2, a3, a4, a5);
-    return instance;
-  } else {
-    return new Klass(a1, a2, a3, a4, a5);
-  }
-};
-
-var standardReleaser = function(instance) {
-  var Klass = this;
-  if (instance.destructor) {
-    instance.destructor();
-  }
-  if (Klass.instancePool.length < Klass.poolSize) {
-    Klass.instancePool.push(instance);
-  }
-};
-
-var DEFAULT_POOL_SIZE = 10;
-var DEFAULT_POOLER = oneArgumentPooler;
-
-/**
- * Augments `CopyConstructor` to be a poolable class, augmenting only the class
- * itself (statically) not adding any prototypical fields. Any CopyConstructor
- * you give this may have a `poolSize` property, and will look for a
- * prototypical `destructor` on instances (optional).
- *
- * @param {Function} CopyConstructor Constructor that can be used to reset.
- * @param {Function} pooler Customizable pooler.
- */
-var addPoolingTo = function(CopyConstructor, pooler) {
-  var NewKlass = CopyConstructor;
-  NewKlass.instancePool = [];
-  NewKlass.getPooled = pooler || DEFAULT_POOLER;
-  if (!NewKlass.poolSize) {
-    NewKlass.poolSize = DEFAULT_POOL_SIZE;
-  }
-  NewKlass.release = standardReleaser;
-  return NewKlass;
-};
-
-var PooledClass = {
-  addPoolingTo: addPoolingTo,
-  oneArgumentPooler: oneArgumentPooler,
-  twoArgumentPooler: twoArgumentPooler,
-  fiveArgumentPooler: fiveArgumentPooler
-};
-
-module.exports = PooledClass;
diff --git a/React/React.js b/React/React.js
deleted file mode 100644
index 3839a44c8d..0000000000
--- a/React/React.js
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule React
- */
-
-"use strict";
-
-var ReactCompositeComponent = require("./ReactCompositeComponent");
-var ReactComponent = require("./ReactComponent");
-var ReactDOM = require("./ReactDOM");
-var ReactMount = require("./ReactMount");
-
-var ReactDefaultInjection = require("./ReactDefaultInjection");
-
-ReactDefaultInjection.inject();
-
-var React = {
-  DOM: ReactDOM,
-  initializeTouchEvents: function(shouldUseTouch) {
-    ReactMount.useTouchEvents = shouldUseTouch;
-  },
-  autoBind: ReactCompositeComponent.autoBind,
-  createClass: ReactCompositeComponent.createClass,
-  createComponentRenderer: ReactMount.createComponentRenderer,
-  constructAndRenderComponent: ReactMount.constructAndRenderComponent,
-  constructAndRenderComponentByID: ReactMount.constructAndRenderComponentByID,
-  renderComponent: ReactMount.renderComponent,
-  unmountAndReleaseReactRootNode: ReactMount.unmountAndReleaseReactRootNode,
-  isValidComponent: ReactComponent.isValidComponent
-};
-
-module.exports = React;
diff --git a/React/ReactComponent.js b/React/ReactComponent.js
deleted file mode 100644
index bd37689cc1..0000000000
--- a/React/ReactComponent.js
+++ /dev/null
@@ -1,402 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactComponent
- */
-
-"use strict";
-
-var ExecutionEnvironment = require("./ExecutionEnvironment");
-var ReactCurrentOwner = require("./ReactCurrentOwner");
-var ReactDOMIDOperations = require("./ReactDOMIDOperations");
-var ReactMount = require("./ReactMount");
-var ReactOwner = require("./ReactOwner");
-var ReactReconcileTransaction = require("./ReactReconcileTransaction");
-
-var invariant = require("./invariant");
-var keyMirror = require("./keyMirror");
-var merge = require("./merge");
-
-/**
- * Prop key that references a component's owner.
- * @private
- */
-var OWNER = '{owner}';
-
-/**
- * Every React component is in one of these life cycles.
- */
-var ComponentLifeCycle = keyMirror({
-  /**
-   * Mounted components have a DOM node representation and are capable of
-   * receiving new props.
-   */
-  MOUNTED: null,
-  /**
-   * Unmounted components are inactive and cannot receive new props.
-   */
-  UNMOUNTED: null
-});
-
-/**
- * Components are the basic units of composition in React.
- *
- * Every component accepts a set of keyed input parameters known as "props" that
- * are initialized by the constructor. Once a component is mounted, the props
- * can be mutated using `setProps` or `replaceProps`.
- *
- * Every component is capable of the following operations:
- *
- *   `mountComponent`
- *     Initializes the component, renders markup, and registers event listeners.
- *
- *   `receiveProps`
- *     Updates the rendered DOM nodes given a new set of props.
- *
- *   `unmountComponent`
- *     Releases any resources allocated by this component.
- *
- * Components can also be "owned" by other components. Being owned by another
- * component means being constructed by that component. This is different from
- * being the child of a component, which means having a DOM representation that
- * is a child of the DOM representation of that component.
- *
- * @class ReactComponent
- */
-var ReactComponent = {
-
-  /**
-   * @param {?object} object
-   * @return {boolean} True if `object` is a valid component.
-   * @final
-   */
-  isValidComponent: function(object) {
-    return !!(
-      object &&
-      typeof object.mountComponentIntoNode === 'function' &&
-      typeof object.receiveProps === 'function'
-    );
-  },
-
-  /**
-   * @internal
-   */
-  LifeCycle: ComponentLifeCycle,
-
-  /**
-   * React references `ReactDOMIDOperations` using this property in order to
-   * allow dependency injection.
-   *
-   * @internal
-   */
-  DOMIDOperations: ReactDOMIDOperations,
-
-  /**
-   * React references `ReactReconcileTransaction` using this property in order
-   * to allow dependency injection.
-   *
-   * @internal
-   */
-  ReactReconcileTransaction: ReactReconcileTransaction,
-
-  /**
-   * @param {object} DOMIDOperations
-   * @final
-   */
-  setDOMOperations: function(DOMIDOperations) {
-    ReactComponent.DOMIDOperations = DOMIDOperations;
-  },
-
-  /**
-   * @param {Transaction} ReactReconcileTransaction
-   * @final
-   */
-  setReactReconcileTransaction: function(ReactReconcileTransaction) {
-    ReactComponent.ReactReconcileTransaction = ReactReconcileTransaction;
-  },
-
-  /**
-   * Base functionality for every ReactComponent constructor.
-   *
-   * @lends {ReactComponent.prototype}
-   */
-  Mixin: {
-
-    /**
-     * Returns the DOM node rendered by this component.
-     *
-     * @return {?DOMElement} The root node of this component.
-     * @final
-     * @protected
-     */
-    getDOMNode: function() {
-      invariant(
-        ExecutionEnvironment.canUseDOM,
-        'getDOMNode(): The DOM is not supported in the current environment.'
-      );
-      invariant(
-        this._lifeCycleState === ComponentLifeCycle.MOUNTED,
-        'getDOMNode(): A component must be mounted to have a DOM node.'
-      );
-      var rootNode = this._rootNode;
-      if (!rootNode) {
-        rootNode = document.getElementById(this._rootNodeID);
-        if (!rootNode) {
-          // TODO: Log the frequency that we reach this path.
-          rootNode = ReactMount.findReactRenderedDOMNodeSlow(this._rootNodeID);
-        }
-        this._rootNode = rootNode;
-      }
-      return rootNode;
-    },
-
-    /**
-     * Sets a subset of the props.
-     *
-     * @param {object} partialProps Subset of the next props.
-     * @final
-     * @public
-     */
-    setProps: function(partialProps) {
-      this.replaceProps(merge(this.props, partialProps));
-    },
-
-    /**
-     * Replaces all of the props.
-     *
-     * @param {object} props New props.
-     * @final
-     * @public
-     */
-    replaceProps: function(props) {
-      invariant(
-        !this.props[OWNER],
-        'replaceProps(...): You called `setProps` or `replaceProps` on a ' +
-        'component with an owner. This is an anti-pattern since props will ' +
-        'get reactively updated when rendered. Instead, change the owner\'s ' +
-        '`render` method to pass the correct value as props to the component ' +
-        'where it is created.'
-      );
-      var transaction = ReactComponent.ReactReconcileTransaction.getPooled();
-      transaction.perform(this.receiveProps, this, props, transaction);
-      ReactComponent.ReactReconcileTransaction.release(transaction);
-    },
-
-    /**
-     * Base constructor for all React component.
-     *
-     * Subclasses that override this method should make sure to invoke
-     * `ReactComponent.Mixin.construct.call(this, ...)`.
-     *
-     * @param {?object} initialProps
-     * @param {*} children
-     * @internal
-     */
-    construct: function(initialProps, children) {
-      this.props = initialProps || {};
-      if (typeof children !== 'undefined') {
-        this.props.children = children;
-      }
-      // Record the component responsible for creating this component.
-      this.props[OWNER] = ReactCurrentOwner.current;
-      // All components start unmounted.
-      this._lifeCycleState = ComponentLifeCycle.UNMOUNTED;
-    },
-
-    /**
-     * Initializes the component, renders markup, and registers event listeners.
-     *
-     * NOTE: This does not insert any nodes into the DOM.
-     *
-     * Subclasses that override this method should make sure to invoke
-     * `ReactComponent.Mixin.mountComponent.call(this, ...)`.
-     *
-     * @param {string} rootID DOM ID of the root node.
-     * @param {ReactReconcileTransaction} transaction
-     * @return {?string} Rendered markup to be inserted into the DOM.
-     * @internal
-     */
-    mountComponent: function(rootID, transaction) {
-      invariant(
-        this._lifeCycleState === ComponentLifeCycle.UNMOUNTED,
-        'mountComponent(%s, ...): Can only mount an unmounted component.',
-        rootID
-      );
-      var props = this.props;
-      if (props.ref != null) {
-        ReactOwner.addComponentAsRefTo(this, props.ref, props[OWNER]);
-      }
-      this._rootNodeID = rootID;
-      this._lifeCycleState = ComponentLifeCycle.MOUNTED;
-      // Effectively: return '';
-    },
-
-    /**
-     * Releases any resources allocated by `mountComponent`.
-     *
-     * NOTE: This does not remove any nodes from the DOM.
-     *
-     * Subclasses that override this method should make sure to invoke
-     * `ReactComponent.Mixin.unmountComponent.call(this)`.
-     *
-     * @internal
-     */
-    unmountComponent: function() {
-      invariant(
-        this._lifeCycleState === ComponentLifeCycle.MOUNTED,
-        'unmountComponent(): Can only unmount a mounted component.'
-      );
-      var props = this.props;
-      if (props.ref != null) {
-        ReactOwner.removeComponentAsRefFrom(this, props.ref, props[OWNER]);
-      }
-      this._rootNode = null;
-      this._rootNodeID = null;
-      this._lifeCycleState = ComponentLifeCycle.UNMOUNTED;
-    },
-
-    /**
-     * Updates the rendered DOM nodes given a new set of props.
-     *
-     * Subclasses that override this method should make sure to invoke
-     * `ReactComponent.Mixin.receiveProps.call(this, ...)`.
-     *
-     * @param {object} nextProps Next set of properties.
-     * @param {ReactReconcileTransaction} transaction
-     * @internal
-     */
-    receiveProps: function(nextProps, transaction) {
-      invariant(
-        this._lifeCycleState === ComponentLifeCycle.MOUNTED,
-        'receiveProps(...): Can only update a mounted component.'
-      );
-      var props = this.props;
-      // If either the owner or a `ref` has changed, make sure the newest owner
-      // has stored a reference to `this`, and the previous owner (if different)
-      // has forgotten the reference to `this`.
-      if (nextProps[OWNER] !== props[OWNER] || nextProps.ref !== props.ref) {
-        if (props.ref != null) {
-          ReactOwner.removeComponentAsRefFrom(this, props.ref, props[OWNER]);
-        }
-        // Correct, even if the owner is the same, and only the ref has changed.
-        if (nextProps.ref != null) {
-          ReactOwner.addComponentAsRefTo(this, nextProps.ref, nextProps[OWNER]);
-        }
-      }
-    },
-
-    /**
-     * Mounts this component and inserts it into the DOM.
-     *
-     * @param {string} rootID DOM ID of the root node.
-     * @param {DOMElement} container DOM element to mount into.
-     * @final
-     * @internal
-     * @see {ReactMount.renderComponent}
-     */
-    mountComponentIntoNode: function(rootID, container) {
-      var transaction = ReactComponent.ReactReconcileTransaction.getPooled();
-      transaction.perform(
-        this._mountComponentIntoNode,
-        this,
-        rootID,
-        container,
-        transaction
-      );
-      ReactComponent.ReactReconcileTransaction.release(transaction);
-    },
-
-    /**
-     * @param {string} rootID DOM ID of the root node.
-     * @param {DOMElement} container DOM element to mount into.
-     * @param {ReactReconcileTransaction} transaction
-     * @final
-     * @private
-     */
-    _mountComponentIntoNode: function(rootID, container, transaction) {
-      var renderStart = Date.now();
-      var markup = this.mountComponent(rootID, transaction);
-      ReactMount.totalInstantiationTime += (Date.now() - renderStart);
-
-      var injectionStart = Date.now();
-      // Asynchronously inject markup by ensuring that the container is not in
-      // the document when settings its `innerHTML`.
-      var parent = container.parentNode;
-      if (parent) {
-        var next = container.nextSibling;
-        parent.removeChild(container);
-        container.innerHTML = markup;
-        if (next) {
-          parent.insertBefore(container, next);
-        } else {
-          parent.appendChild(container);
-        }
-      } else {
-        container.innerHTML = markup;
-      }
-      ReactMount.totalInjectionTime += (Date.now() - injectionStart);
-    },
-
-    /**
-     * Unmounts this component and removes it from the DOM.
-     *
-     * @param {DOMElement} container DOM element to unmount from.
-     * @final
-     * @internal
-     * @see {ReactMount.unmountAndReleaseReactRootNode}
-     */
-    unmountComponentFromNode: function(container) {
-      this.unmountComponent();
-      // http://jsperf.com/emptying-a-node
-      while (container.lastChild) {
-        container.removeChild(container.lastChild);
-      }
-    },
-
-    /**
-     * Checks if this component is owned by the supplied `owner` component.
-     *
-     * @param {ReactComponent} owner Component to check.
-     * @return {boolean} True if `owners` owns this component.
-     * @final
-     * @internal
-     */
-    isOwnedBy: function(owner) {
-      return this.props[OWNER] === owner;
-    }
-
-  }
-
-};
-
-function logDeprecated(msg) {
-  if (true) {
-    throw new Error(msg);
-  }
-}
-
-/**
- * @deprecated
- */
-ReactComponent.Mixin.update = function(props) {
-  logDeprecated('this.update() is deprecated. Use this.setProps()');
-  this.setProps(props);
-};
-ReactComponent.Mixin.updateAll = function(props) {
-  logDeprecated('this.updateAll() is deprecated. Use this.replaceProps()');
-  this.replaceProps(props);
-};
-
-module.exports = ReactComponent;
diff --git a/React/ReactCompositeComponent.js b/React/ReactCompositeComponent.js
deleted file mode 100644
index 8c8ca667d7..0000000000
--- a/React/ReactCompositeComponent.js
+++ /dev/null
@@ -1,836 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactCompositeComponent
- */
-
-"use strict";
-
-var ReactComponent = require("./ReactComponent");
-var ReactCurrentOwner = require("./ReactCurrentOwner");
-var ReactOwner = require("./ReactOwner");
-var ReactPropTransferer = require("./ReactPropTransferer");
-
-var invariant = require("./invariant");
-var keyMirror = require("./keyMirror");
-var merge = require("./merge");
-var mixInto = require("./mixInto");
-
-/**
- * Policies that describe methods in `ReactCompositeComponentInterface`.
- */
-var SpecPolicy = keyMirror({
-  /**
-   * These methods may be defined only once by the class specification or mixin.
-   */
-  DEFINE_ONCE: null,
-  /**
-   * These methods may be defined by both the class specification and mixins.
-   * Subsequent definitions will be chained. These methods must return void.
-   */
-  DEFINE_MANY: null,
-  /**
-   * These methods are overriding the base ReactCompositeComponent class.
-   */
-  OVERRIDE_BASE: null
-});
-
-/**
- * Composite components are higher-level components that compose other composite
- * or native components.
- *
- * To create a new type of `ReactCompositeComponent`, pass a specification of
- * your new class to `React.createClass`. The only requirement of your class
- * specification is that you implement a `render` method.
- *
- *   var MyComponent = React.createClass({
- *     render: function() {
- *       return <div>Hello World</div>;
- *     }
- *   });
- *
- * The class specification supports a specific protocol of methods that have
- * special meaning (e.g. `render`). See `ReactCompositeComponentInterface` for
- * more the comprehensive protocol. Any other properties and methods in the
- * class specification will available on the prototype.
- *
- * @interface ReactCompositeComponentInterface
- * @internal
- */
-var ReactCompositeComponentInterface = {
-
-  /**
-   * An array of Mixin objects to include when defining your component.
-   *
-   * @type {array}
-   * @optional
-   */
-  mixins: SpecPolicy.DEFINE_MANY,
-
-  /**
-   * Definition of props for this component.
-   *
-   * @type {array}
-   * @optional
-   */
-  props: SpecPolicy.DEFINE_ONCE,
-
-
-
-  // ==== Definition methods ====
-
-  /**
-   * Invoked once before the component is mounted. The return value will be used
-   * as the initial value of `this.state`.
-   *
-   *   getInitialState: function() {
-   *     return {
-   *       isOn: false,
-   *       fooBaz: new BazFoo()
-   *     }
-   *   }
-   *
-   * @return {object}
-   * @optional
-   */
-  getInitialState: SpecPolicy.DEFINE_ONCE,
-
-  /**
-   * Uses props from `this.props` and state from `this.state` to render the
-   * structure of the component.
-   *
-   * No guarantees are made about when or how often this method is invoked, so
-   * it must not have side effects.
-   *
-   *   render: function() {
-   *     var name = this.props.name;
-   *     return <div>Hello, {name}!</div>;
-   *   }
-   *
-   * @return {ReactComponent}
-   * @nosideeffects
-   * @required
-   */
-  render: SpecPolicy.DEFINE_ONCE,
-
-
-
-  // ==== Delegate methods ====
-
-  /**
-   * Invoked when the component is initially created and about to be mounted.
-   * This may have side effects, but any external subscriptions or data created
-   * by this method must be cleaned up in `componentWillUnmount`.
-   *
-   * @optional
-   */
-  componentWillMount: SpecPolicy.DEFINE_MANY,
-
-  /**
-   * Invoked when the component has been mounted and has a DOM representation.
-   * However, there is no guarantee that the DOM node is in the document.
-   *
-   * Use this as an opportunity to operate on the DOM when the component has
-   * been mounted (initialized and rendered) for the first time.
-   *
-   * @param {DOMElement} rootNode DOM element representing the component.
-   * @optional
-   */
-  componentDidMount: SpecPolicy.DEFINE_MANY,
-
-  /**
-   * Invoked before the component receives new props.
-   *
-   * Use this as an opportunity to react to a prop transition by updating the
-   * state using `this.setState`. Current props are accessed via `this.props`.
-   *
-   *   componentWillReceiveProps: function(nextProps) {
-   *     this.setState({
-   *       likesIncreasing: nextProps.likeCount > this.props.likeCount
-   *     });
-   *   }
-   *
-   * NOTE: There is no equivalent `componentWillReceiveState`. An incoming prop
-   * transition may cause a state change, but the opposite is not true. If you
-   * need it, you are probably looking for `componentWillUpdate`.
-   *
-   * @param {object} nextProps
-   * @optional
-   */
-  componentWillReceiveProps: SpecPolicy.DEFINE_MANY,
-
-  /**
-   * Invoked while deciding if the component should be updated as a result of
-   * receiving new props and state.
-   *
-   * Use this as an opportunity to `return false` when you're certain that the
-   * transition to the new props and state will not require a component update.
-   *
-   *   shouldComponentUpdate: function(nextProps, nextState) {
-   *     return !equal(nextProps, this.props) || !equal(nextState, this.state);
-   *   }
-   *
-   * @param {object} nextProps
-   * @param {?object} nextState
-   * @return {boolean} True if the component should update.
-   * @optional
-   */
-  shouldComponentUpdate: SpecPolicy.DEFINE_ONCE,
-
-  /**
-   * Invoked when the component is about to update due to a transition from
-   * `this.props` and `this.state` to `nextProps` and `nextState`.
-   *
-   * Use this as an opportunity to perform preparation before an update occurs.
-   *
-   * NOTE: You **cannot** use `this.setState()` in this method.
-   *
-   * @param {object} nextProps
-   * @param {?object} nextState
-   * @param {ReactReconcileTransaction} transaction
-   * @optional
-   */
-  componentWillUpdate: SpecPolicy.DEFINE_MANY,
-
-  /**
-   * Invoked when the component's DOM representation has been updated.
-   *
-   * Use this as an opportunity to operate on the DOM when the component has
-   * been updated.
-   *
-   * @param {object} prevProps
-   * @param {?object} prevState
-   * @param {DOMElement} rootNode DOM element representing the component.
-   * @optional
-   */
-  componentDidUpdate: SpecPolicy.DEFINE_MANY,
-
-  /**
-   * Invoked when the component is about to be removed from its parent and have
-   * its DOM representation destroyed.
-   *
-   * Use this as an opportunity to deallocate any external resources.
-   *
-   * NOTE: There is no `componentDidUnmount` since your component will have been
-   * destroyed by that point.
-   *
-   * @optional
-   */
-  componentWillUnmount: SpecPolicy.DEFINE_MANY,
-
-
-
-  // ==== Advanced methods ====
-
-  /**
-   * Updates the component's currently mounted DOM representation.
-   *
-   * By default, this implements React's rendering and reconciliation algorithm.
-   * Sophisticated clients may wish to override this.
-   *
-   * @param {ReactReconcileTransaction} transaction
-   * @internal
-   * @overridable
-   */
-  updateComponent: SpecPolicy.OVERRIDE_BASE
-
-};
-
-/**
- * Mapping from class specification keys to special processing functions.
- *
- * Although these are declared in the specification when defining classes
- * using `React.createClass`, they will not be on the component's prototype.
- */
-var RESERVED_SPEC_KEYS = {
-  displayName: function(Constructor, displayName) {
-    Constructor.displayName = displayName;
-  },
-  mixins: function(Constructor, mixins) {
-    if (mixins) {
-      for (var i = 0; i < mixins.length; i++) {
-        mixSpecIntoComponent(Constructor, mixins[i]);
-      }
-    }
-  },
-  props: function(Constructor, props) {
-    Constructor.propDeclarations = props;
-  }
-};
-
-/**
- * Custom version of `mixInto` which handles policy validation and reserved
- * specification keys when building `ReactCompositeComponent` classses.
- */
-function mixSpecIntoComponent(Constructor, spec) {
-  var proto = Constructor.prototype;
-  for (var name in spec) {
-    if (!spec.hasOwnProperty(name)) {
-      continue;
-    }
-    var property = spec[name];
-    var specPolicy = ReactCompositeComponentInterface[name];
-
-    // Disallow overriding of base class methods unless explicitly allowed.
-    if (ReactCompositeComponentMixin.hasOwnProperty(name)) {
-      invariant(
-        specPolicy === SpecPolicy.OVERRIDE_BASE,
-        'ReactCompositeComponentInterface: You are attempting to override ' +
-        '`%s` from your class specification. Ensure that your method names ' +
-        'do not overlap with React methods.',
-        name
-      );
-    }
-
-    // Disallow using `React.autoBind` on internal methods.
-    if (specPolicy != null) {
-      invariant(
-        !property || !property.__reactAutoBind,
-        'ReactCompositeComponentInterface: You are attempting to use ' +
-        '`React.autoBind` on `%s`, a method that is internal to React.' +
-        'Internal methods are called with the component as the context.',
-        name
-      );
-    }
-
-    // Disallow defining methods more than once unless explicitly allowed.
-    if (proto.hasOwnProperty(name)) {
-      invariant(
-        specPolicy === SpecPolicy.DEFINE_MANY,
-        'ReactCompositeComponentInterface: You are attempting to define ' +
-        '`%s` on your component more than once. This conflict may be due ' +
-        'to a mixin.',
-        name
-      );
-    }
-
-    if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {
-      RESERVED_SPEC_KEYS[name](Constructor, property);
-    } else if (property && property.__reactAutoBind) {
-      if (!proto.__reactAutoBindMap) {
-        proto.__reactAutoBindMap = {};
-      }
-      proto.__reactAutoBindMap[name] = property.__reactAutoBind;
-    } else if (proto.hasOwnProperty(name)) {
-      // For methods which are defined more than once, call the existing methods
-      // before calling the new property.
-      proto[name] = createChainedFunction(proto[name], property);
-    } else {
-      proto[name] = property;
-    }
-  }
-}
-
-/**
- * Creates a function that invokes two functions and ignores their return vales.
- *
- * @param {function} one Function to invoke first.
- * @param {function} two Function to invoke second.
- * @return {function} Function that invokes the two argument functions.
- * @private
- */
-function createChainedFunction(one, two) {
-  return function chainedFunction(a, b, c, d, e, tooMany) {
-    invariant(
-      typeof tooMany === 'undefined',
-      'Chained function can only take a maximum of 5 arguments.'
-    );
-    one.call(this, a, b, c, d, e);
-    two.call(this, a, b, c, d, e);
-  };
-}
-
-/**
- * `ReactCompositeComponent` maintains an auxiliary life cycle state in
- * `this._compositeLifeCycleState` (which can be null).
- *
- * This is different from the life cycle state maintained by `ReactComponent` in
- * `this._lifeCycleState`.
- */
-var CompositeLifeCycle = keyMirror({
-  /**
-   * Components in the process of being mounted respond to state changes
-   * differently.
-   */
-  MOUNTING: null,
-  /**
-   * Components in the process of being unmounted are guarded against state
-   * changes.
-   */
-  UNMOUNTING: null,
-  /**
-   * Components that are mounted and receiving new props respond to state
-   * changes differently.
-   */
-  RECEIVING_PROPS: null,
-  /**
-   * Components that are mounted and receiving new state are guarded against
-   * additional state changes.
-   */
-  RECEIVING_STATE: null
-});
-
-/**
- * @lends {ReactCompositeComponent.prototype}
- */
-var ReactCompositeComponentMixin = {
-
-  /**
-   * Base constructor for all composite component.
-   *
-   * @param {?object} initialProps
-   * @param {*} children
-   * @final
-   * @internal
-   */
-  construct: function(initialProps, children) {
-    ReactComponent.Mixin.construct.call(this, initialProps, children);
-    this.state = null;
-    this._pendingState = null;
-    this._compositeLifeCycleState = null;
-  },
-
-  /**
-   * Initializes the component, renders markup, and registers event listeners.
-   *
-   * @param {string} rootID DOM ID of the root node.
-   * @param {ReactReconcileTransaction} transaction
-   * @return {?string} Rendered markup to be inserted into the DOM.
-   * @final
-   * @internal
-   */
-  mountComponent: function(rootID, transaction) {
-    ReactComponent.Mixin.mountComponent.call(this, rootID, transaction);
-
-    // Unset `this._lifeCycleState` until after this method is finished.
-    this._lifeCycleState = ReactComponent.LifeCycle.UNMOUNTED;
-    this._compositeLifeCycleState = CompositeLifeCycle.MOUNTING;
-
-    if (this.constructor.propDeclarations) {
-      this._assertValidProps(this.props);
-    }
-
-    if (this.__reactAutoBindMap) {
-      this._bindAutoBindMethods();
-    }
-
-    this.state = this.getInitialState ? this.getInitialState() : null;
-    this._pendingState = null;
-
-    if (this.componentWillMount) {
-      this.componentWillMount();
-      // When mounting, calls to `setState` by `componentWillMount` will set
-      // `this._pendingState` without triggering a re-render.
-      if (this._pendingState) {
-        this.state = this._pendingState;
-        this._pendingState = null;
-      }
-    }
-
-    if (this.componentDidMount) {
-      transaction.getReactOnDOMReady().enqueue(this, this.componentDidMount);
-    }
-
-    this._renderedComponent = this._renderValidatedComponent();
-
-    // Done with mounting, `setState` will now trigger UI changes.
-    this._compositeLifeCycleState = null;
-    this._lifeCycleState = ReactComponent.LifeCycle.MOUNTED;
-
-    return this._renderedComponent.mountComponent(rootID, transaction);
-  },
-
-  /**
-   * Releases any resources allocated by `mountComponent`.
-   *
-   * @final
-   * @internal
-   */
-  unmountComponent: function() {
-    this._compositeLifeCycleState = CompositeLifeCycle.UNMOUNTING;
-    if (this.componentWillUnmount) {
-      this.componentWillUnmount();
-    }
-    this._compositeLifeCycleState = null;
-
-    ReactComponent.Mixin.unmountComponent.call(this);
-    this._renderedComponent.unmountComponent();
-    this._renderedComponent = null;
-
-    if (this.refs) {
-      this.refs = null;
-    }
-
-    // Some existing components rely on this.props even after they've been
-    // destroyed (in event handlers).
-    // TODO: this.props = null;
-    // TODO: this.state = null;
-  },
-
-  /**
-   * Updates the rendered DOM nodes given a new set of props.
-   *
-   * @param {object} nextProps Next set of properties.
-   * @param {ReactReconcileTransaction} transaction
-   * @final
-   * @internal
-   */
-  receiveProps: function(nextProps, transaction) {
-    if (this.constructor.propDeclarations) {
-      this._assertValidProps(nextProps);
-    }
-    ReactComponent.Mixin.receiveProps.call(this, nextProps, transaction);
-
-    this._compositeLifeCycleState = CompositeLifeCycle.RECEIVING_PROPS;
-    if (this.componentWillReceiveProps) {
-      this.componentWillReceiveProps(nextProps, transaction);
-    }
-    this._compositeLifeCycleState = CompositeLifeCycle.RECEIVING_STATE;
-    // When receiving props, calls to `setState` by `componentWillReceiveProps`
-    // will set `this._pendingState` without triggering a re-render.
-    var nextState = this._pendingState || this.state;
-    this._pendingState = null;
-    this._receivePropsAndState(nextProps, nextState, transaction);
-    this._compositeLifeCycleState = null;
-  },
-
-  /**
-   * Sets a subset of the state. Always use this or `replaceState` to mutate
-   * state. You should treat `this.state` as immutable.
-   *
-   * There is no guarantee that `this.state` will be immediately updated, so
-   * accessing `this.state` after calling this method may return the old value.
-   *
-   * @param {object} partialState Next partial state to be merged with state.
-   * @final
-   * @protected
-   */
-  setState: function(partialState) {
-    // Merge with `_pendingState` if it exists, otherwise with existing state.
-    this.replaceState(merge(this._pendingState || this.state, partialState));
-  },
-
-  /**
-   * Replaces all of the state. Always use this or `setState` to mutate state.
-   * You should treat `this.state` as immutable.
-   *
-   * There is no guarantee that `this.state` will be immediately updated, so
-   * accessing `this.state` after calling this method may return the old value.
-   *
-   * @param {object} completeState Next state.
-   * @final
-   * @protected
-   */
-  replaceState: function(completeState) {
-    var compositeLifeCycleState = this._compositeLifeCycleState;
-    invariant(
-      this._lifeCycleState === ReactComponent.LifeCycle.MOUNTED ||
-      compositeLifeCycleState === CompositeLifeCycle.MOUNTING,
-      'replaceState(...): Can only update a mounted (or mounting) component.'
-    );
-    invariant(
-      compositeLifeCycleState !== CompositeLifeCycle.RECEIVING_STATE &&
-      compositeLifeCycleState !== CompositeLifeCycle.UNMOUNTING,
-      'replaceState(...): Cannot update while unmounting component or during ' +
-      'an existing state transition (such as within `render`).'
-    );
-
-    this._pendingState = completeState;
-
-    // Do not trigger a state transition if we are in the middle of mounting or
-    // receiving props because both of those will already be doing this.
-    if (compositeLifeCycleState !== CompositeLifeCycle.MOUNTING &&
-        compositeLifeCycleState !== CompositeLifeCycle.RECEIVING_PROPS) {
-      this._compositeLifeCycleState = CompositeLifeCycle.RECEIVING_STATE;
-
-      var nextState = this._pendingState;
-      this._pendingState = null;
-
-      var transaction = ReactComponent.ReactReconcileTransaction.getPooled();
-      transaction.perform(
-        this._receivePropsAndState,
-        this,
-        this.props,
-        nextState,
-        transaction
-      );
-      ReactComponent.ReactReconcileTransaction.release(transaction);
-
-      this._compositeLifeCycleState = null;
-    }
-  },
-
-  /**
-   * Receives next props and next state, and negotiates whether or not the
-   * component should update as a result.
-   *
-   * @param {object} nextProps Next object to set as props.
-   * @param {?object} nextState Next object to set as state.
-   * @param {ReactReconcileTransaction} transaction
-   * @private
-   */
-  _receivePropsAndState: function(nextProps, nextState, transaction) {
-    if (!this.shouldComponentUpdate ||
-        this.shouldComponentUpdate(nextProps, nextState)) {
-      // Will set `this.props` and `this.state`.
-      this._performComponentUpdate(nextProps, nextState, transaction);
-    } else {
-      // If it's determined that a component should not update, we still want
-      // to set props and state.
-      this.props = nextProps;
-      this.state = nextState;
-    }
-  },
-
-  /**
-   * Merges new props and state, notifies delegate methods of update and
-   * performs update.
-   *
-   * @param {object} nextProps Next object to set as properties.
-   * @param {?object} nextState Next object to set as state.
-   * @param {ReactReconcileTransaction} transaction
-   * @private
-   */
-  _performComponentUpdate: function(nextProps, nextState, transaction) {
-    var prevProps = this.props;
-    var prevState = this.state;
-
-    if (this.componentWillUpdate) {
-      this.componentWillUpdate(nextProps, nextState, transaction);
-    }
-
-    this.props = nextProps;
-    this.state = nextState;
-
-    this.updateComponent(transaction);
-
-    if (this.componentDidUpdate) {
-      transaction.getReactOnDOMReady().enqueue(
-        this,
-        this.componentDidUpdate.bind(this, prevProps, prevState)
-      );
-    }
-  },
-
-  /**
-   * Updates the component's currently mounted DOM representation.
-   *
-   * By default, this implements React's rendering and reconciliation algorithm.
-   * Sophisticated clients may wish to override this.
-   *
-   * @param {ReactReconcileTransaction} transaction
-   * @internal
-   * @overridable
-   */
-  updateComponent: function(transaction) {
-    var currentComponent = this._renderedComponent;
-    var nextComponent = this._renderValidatedComponent();
-    if (currentComponent.constructor === nextComponent.constructor) {
-      if (!nextComponent.props.isStatic) {
-        currentComponent.receiveProps(nextComponent.props, transaction);
-      }
-    } else {
-      // These two IDs are actually the same! But nothing should rely on that.
-      var thisID = this._rootNodeID;
-      var currentComponentID = currentComponent._rootNodeID;
-      currentComponent.unmountComponent();
-      var nextMarkup = nextComponent.mountComponent(thisID, transaction);
-      ReactComponent.DOMIDOperations.dangerouslyReplaceNodeWithMarkupByID(
-        currentComponentID,
-        nextMarkup
-      );
-      this._renderedComponent = nextComponent;
-    }
-  },
-
-  /**
-   * Forces an update. This should only be invoked when it is known with
-   * certainty that we are **not** in a DOM transaction.
-   *
-   * You may want to call this when you know that some deeper aspect of the
-   * component's state has changed but `setState` was not called.
-   *
-   * This will not invoke `shouldUpdateComponent`, but it will invoke
-   * `componentWillUpdate` and `componentDidUpdate`.
-   *
-   * @final
-   * @protected
-   */
-  forceUpdate: function() {
-    var transaction = ReactComponent.ReactReconcileTransaction.getPooled();
-    transaction.perform(
-      this._performComponentUpdate,
-      this,
-      this.props,
-      this.state,
-      transaction
-    );
-    ReactComponent.ReactReconcileTransaction.release(transaction);
-  },
-
-  /**
-   * @private
-   */
-  _renderValidatedComponent: function() {
-    ReactCurrentOwner.current = this;
-    var renderedComponent = this.render();
-    ReactCurrentOwner.current = null;
-    invariant(
-      ReactComponent.isValidComponent(renderedComponent),
-      '%s.render(): A valid ReactComponent must be returned.',
-      this.constructor.displayName || 'ReactCompositeComponent'
-    );
-    return renderedComponent;
-  },
-
-  /**
-   * @param {object} props
-   * @private
-   */
-  _assertValidProps: function(props) {
-    var propDeclarations = this.constructor.propDeclarations;
-    var componentName = this.constructor.displayName;
-    for (var propName in propDeclarations) {
-      var checkProp = propDeclarations[propName];
-      if (checkProp) {
-        checkProp(props, propName, componentName);
-      }
-    }
-  },
-
-  /**
-   * @private
-   */
-  _bindAutoBindMethods: function() {
-    for (var autoBindKey in this.__reactAutoBindMap) {
-      if (!this.__reactAutoBindMap.hasOwnProperty(autoBindKey)) {
-        continue;
-      }
-      var method = this.__reactAutoBindMap[autoBindKey];
-      this[autoBindKey] = this._bindAutoBindMethod(method);
-    }
-  },
-
-  /**
-   * Binds a method to the component.
-   *
-   * @param {function} method Method to be bound.
-   * @private
-   */
-  _bindAutoBindMethod: function(method) {
-    var component = this;
-    var hasWarned = false;
-    function autoBound(a, b, c, d, e, tooMany) {
-      invariant(
-        typeof tooMany === 'undefined',
-        'React.autoBind(...): Methods can only take a maximum of 5 arguments.'
-      );
-      if (component._lifeCycleState === ReactComponent.LifeCycle.MOUNTED) {
-        return method.call(component, a, b, c, d, e);
-      } else if (!hasWarned) {
-        hasWarned = true;
-        if (true) {
-          console.warn(
-            'React.autoBind(...): Attempted to invoke an auto-bound method ' +
-            'on an unmounted instance of `%s`. You either have a memory leak ' +
-            'or an event handler that is being run after unmounting.',
-            component.constructor.displayName || 'ReactCompositeComponent'
-          );
-        }
-      }
-    }
-    return autoBound;
-  }
-
-};
-
-var ReactCompositeComponentBase = function() {};
-mixInto(ReactCompositeComponentBase, ReactComponent.Mixin);
-mixInto(ReactCompositeComponentBase, ReactOwner.Mixin);
-mixInto(ReactCompositeComponentBase, ReactPropTransferer.Mixin);
-mixInto(ReactCompositeComponentBase, ReactCompositeComponentMixin);
-
-/**
- * Module for creating composite components.
- *
- * @class ReactCompositeComponent
- * @extends ReactComponent
- * @extends ReactOwner
- * @extends ReactPropTransferer
- */
-var ReactCompositeComponent = {
-
-  LifeCycle: CompositeLifeCycle,
-
-  Base: ReactCompositeComponentBase,
-
-  /**
-   * Creates a composite component class given a class specification.
-   *
-   * @param {object} spec Class specification (which must define `render`).
-   * @return {function} Component constructor function.
-   * @public
-   */
-  createClass: function(spec) {
-    var Constructor = function(initialProps, children) {
-      this.construct(initialProps, children);
-    };
-    Constructor.prototype = new ReactCompositeComponentBase();
-    Constructor.prototype.constructor = Constructor;
-    mixSpecIntoComponent(Constructor, spec);
-    invariant(
-      Constructor.prototype.render,
-      'createClass(...): Class specification must implement a `render` method.'
-    );
-
-    var ConvenienceConstructor = function(props, children) {
-      return new Constructor(props, children);
-    };
-    ConvenienceConstructor.componentConstructor = Constructor;
-    ConvenienceConstructor.originalSpec = spec;
-    return ConvenienceConstructor;
-  },
-
-  /**
-   * Marks the provided method to be automatically bound to the component.
-   * This means the method's context will always be the component.
-   *
-   *   React.createClass({
-   *     handleClick: React.autoBind(function() {
-   *       this.setState({jumping: true});
-   *     }),
-   *     render: function() {
-   *       return <a onClick={this.handleClick}>Jump</a>;
-   *     }
-   *   });
-   *
-   * @param {function} method Method to be bound.
-   * @public
-   */
-  autoBind: function(method) {
-    function unbound() {
-      invariant(
-        false,
-        'React.autoBind(...): Attempted to invoke an auto-bound method that ' +
-        'was not correctly defined on the class specification.'
-      );
-    }
-    unbound.__reactAutoBind = method;
-    return unbound;
-  }
-
-};
-
-module.exports = ReactCompositeComponent;
diff --git a/React/ReactCurrentOwner.js b/React/ReactCurrentOwner.js
deleted file mode 100644
index 819071ff75..0000000000
--- a/React/ReactCurrentOwner.js
+++ /dev/null
@@ -1,37 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactCurrentOwner
- */
-
-"use strict";
-
-/**
- * Keeps track of the current owner.
- *
- * The current owner is the component who should own any components that are
- * currently being constructed.
- */
-var ReactCurrentOwner = {
-
-  /**
-   * @internal
-   * @type {ReactComponent}
-   */
-  current: null
-
-};
-
-module.exports = ReactCurrentOwner;
diff --git a/React/ReactDOM.js b/React/ReactDOM.js
deleted file mode 100644
index b0febe7267..0000000000
--- a/React/ReactDOM.js
+++ /dev/null
@@ -1,148 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactDOM
- * @typechecks
- */
-
-"use strict";
-
-var ReactNativeComponent = require("./ReactNativeComponent");
-
-var mergeInto = require("./mergeInto");
-var objMapKeyVal = require("./objMapKeyVal");
-
-/**
- * Creates a new React class that is idempotent and capable of containing other
- * React components. It accepts event listeners and DOM properties that are
- * valid according to `DOMProperty`.
- *
- *  - Event listeners: `onClick`, `onMouseDown`, etc.
- *  - DOM properties: `className`, `name`, `title`, etc.
- *
- * The `style` property functions differently from the DOM API. It accepts an
- * object mapping of style properties to values.
- *
- * @param {string} tag Tag name (e.g. `div`).
- * @param {boolean} omitClose True if the close tag should be omitted.
- * @private
- */
-function createDOMComponentClass(tag, omitClose) {
-  var Constructor = function(initialProps, children) {
-    this.construct(initialProps, children);
-  };
-
-  Constructor.prototype = new ReactNativeComponent(tag, omitClose);
-  Constructor.prototype.constructor = Constructor;
-
-  return function(props, children) {
-    return new Constructor(props, children);
-  };
-}
-
-/**
- * Creates a mapping from supported HTML tags to `ReactNativeComponent` classes.
- * This is also accessible via `React.DOM`.
- *
- * @public
- */
-var ReactDOM = objMapKeyVal({
-  a: false,
-  abbr: false,
-  address: false,
-  audio: false,
-  b: false,
-  body: false,
-  br: true,
-  button: false,
-  code: false,
-  col: true,
-  colgroup: false,
-  dd: false,
-  div: false,
-  section: false,
-  dl: false,
-  dt: false,
-  em: false,
-  embed: true,
-  fieldset: false,
-  footer: false,
-  // Danger: this gets monkeypatched! See ReactDOMForm for more info.
-  form: false,
-  h1: false,
-  h2: false,
-  h3: false,
-  h4: false,
-  h5: false,
-  h6: false,
-  header: false,
-  hr: true,
-  i: false,
-  iframe: false,
-  img: true,
-  input: true,
-  label: false,
-  legend: false,
-  li: false,
-  line: false,
-  nav: false,
-  object: false,
-  ol: false,
-  optgroup: false,
-  option: false,
-  p: false,
-  param: true,
-  pre: false,
-  select: false,
-  small: false,
-  source: false,
-  span: false,
-  sub: false,
-  sup: false,
-  strong: false,
-  table: false,
-  tbody: false,
-  td: false,
-  textarea: false,
-  tfoot: false,
-  th: false,
-  thead: false,
-  time: false,
-  title: false,
-  tr: false,
-  u: false,
-  ul: false,
-  video: false,
-  wbr: false,
-
-  // SVG
-  circle: false,
-  g: false,
-  path: false,
-  polyline: false,
-  rect: false,
-  svg: false,
-  text: false
-}, createDOMComponentClass);
-
-var injection = {
-  injectComponentClasses: function(componentClasses) {
-    mergeInto(ReactDOM, componentClasses);
-  }
-};
-
-ReactDOM.injection = injection;
-
-module.exports = ReactDOM;
diff --git a/React/ReactDOMForm.js b/React/ReactDOMForm.js
deleted file mode 100644
index f931130c1f..0000000000
--- a/React/ReactDOMForm.js
+++ /dev/null
@@ -1,52 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactDOMForm
- */
-
-"use strict";
-
-var ReactCompositeComponent = require("./ReactCompositeComponent");
-var ReactDOM = require("./ReactDOM");
-var ReactEvent = require("./ReactEvent");
-var EventConstants = require("./EventConstants");
-
-// Store a reference to the <form> `ReactNativeComponent`.
-var form = ReactDOM.form;
-
-/**
- * Since onSubmit doesn't bubble OR capture on the top level in IE8, we need
- * to capture it on the <form> element itself. There are lots of hacks we could
- * do to accomplish this, but the most reliable is to make <form> a
- * composite component and use `componentDidMount` to attach the event handlers.
- */
-var ReactDOMForm = ReactCompositeComponent.createClass({
-  render: function() {
-    // TODO: Instead of using `ReactDOM` directly, we should use JSX. However,
-    // `jshint` fails to parse JSX so in order for linting to work in the open
-    // source repo, we need to just use `ReactDOM.form`.
-    return this.transferPropsTo(form(null, this.props.children));
-  },
-
-  componentDidMount: function(node) {
-    ReactEvent.trapBubbledEvent(
-      EventConstants.topLevelTypes.topSubmit,
-      'submit',
-      node
-    );
-  }
-});
-
-module.exports = ReactDOMForm;
diff --git a/React/ReactDOMIDOperations.js b/React/ReactDOMIDOperations.js
deleted file mode 100644
index 898de4f532..0000000000
--- a/React/ReactDOMIDOperations.js
+++ /dev/null
@@ -1,166 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactDOMIDOperations
- * @typechecks
- */
-
-/*jslint evil: true */
-
-"use strict";
-
-var CSSPropertyOperations = require("./CSSPropertyOperations");
-var DOMChildrenOperations = require("./DOMChildrenOperations");
-var DOMPropertyOperations = require("./DOMPropertyOperations");
-var ReactDOMNodeCache = require("./ReactDOMNodeCache");
-
-var getTextContentAccessor = require("./getTextContentAccessor");
-var invariant = require("./invariant");
-
-/**
- * Errors for properties that should not be updated with `updatePropertyById()`.
- *
- * @type {object}
- * @private
- */
-var INVALID_PROPERTY_ERRORS = {
-  content: '`content` must be set using `updateTextContentByID()`.',
-  dangerouslySetInnerHTML:
-    '`dangerouslySetInnerHTML` must be set using `updateInnerHTMLByID()`.',
-  style: '`style` must be set using `updateStylesByID()`.'
-};
-
-/**
- * The DOM property to use when setting text content.
- *
- * @type {string}
- * @private
- */
-var textContentAccessor = getTextContentAccessor() || 'NA';
-
-/**
- * Operations used to process updates to DOM nodes. This is made injectable via
- * `ReactComponent.DOMIDOperations`.
- */
-var ReactDOMIDOperations = {
-
-  /**
-   * Updates a DOM node with new property values. This should only be used to
-   * update DOM properties in `DOMProperty`.
-   *
-   * @param {string} id ID of the node to update.
-   * @param {string} name A valid property name, see `DOMProperty`.
-   * @param {*} value New value of the property.
-   * @internal
-   */
-  updatePropertyByID: function(id, name, value) {
-    var node = ReactDOMNodeCache.getCachedNodeByID(id);
-    invariant(
-      !INVALID_PROPERTY_ERRORS.hasOwnProperty(name),
-      'updatePropertyByID(...): %s',
-      INVALID_PROPERTY_ERRORS[name]
-    );
-    DOMPropertyOperations.setValueForProperty(node, name, value);
-  },
-
-  /**
-   * This should almost never be used instead of `updatePropertyByID()` due to
-   * the extra object allocation required by the API. That said, this is useful
-   * for batching up several operations across worker thread boundaries.
-   *
-   * @param {string} id ID of the node to update.
-   * @param {object} properties A mapping of valid property names.
-   * @internal
-   * @see {ReactDOMIDOperations.updatePropertyByID}
-   */
-  updatePropertiesByID: function(id, properties) {
-    for (var name in properties) {
-      if (!properties.hasOwnProperty(name)) {
-        continue;
-      }
-      ReactDOMIDOperations.updatePropertiesByID(id, name, properties[name]);
-    }
-  },
-
-  /**
-   * Updates a DOM node with new style values.
-   *
-   * @param {string} id ID of the node to update.
-   * @param {object} styles Mapping from styles to values.
-   * @internal
-   */
-  updateStylesByID: function(id, styles) {
-    var node = ReactDOMNodeCache.getCachedNodeByID(id);
-    CSSPropertyOperations.setValueForStyles(node, styles);
-  },
-
-  /**
-   * Updates a DOM node's innerHTML set by `props.dangerouslySetInnerHTML`.
-   *
-   * @param {string} id ID of the node to update.
-   * @param {object} html An HTML object with the `__html` property.
-   * @internal
-   */
-  updateInnerHTMLByID: function(id, html) {
-    var node = ReactDOMNodeCache.getCachedNodeByID(id);
-    // HACK: IE8- normalize whitespace in innerHTML, removing leading spaces.
-    // @see quirksmode.org/bugreports/archives/2004/11/innerhtml_and_t.html
-    node.innerHTML = (html && html.__html || '').replace(/^ /g, '&nbsp;');
-  },
-
-  /**
-   * Updates a DOM node's text content set by `props.content`.
-   *
-   * @param {string} id ID of the node to update.
-   * @param {string} content Text content.
-   * @internal
-   */
-  updateTextContentByID: function(id, content) {
-    var node = ReactDOMNodeCache.getCachedNodeByID(id);
-    node[textContentAccessor] = content;
-  },
-
-  /**
-   * Replaces a DOM node that exists in the document with markup.
-   *
-   * @param {string} id ID of child to be replaced.
-   * @param {string} markup Dangerous markup to inject in place of child.
-   * @internal
-   * @see {Danger.dangerouslyReplaceNodeWithMarkup}
-   */
-  dangerouslyReplaceNodeWithMarkupByID: function(id, markup) {
-    var node = ReactDOMNodeCache.getCachedNodeByID(id);
-    DOMChildrenOperations.dangerouslyReplaceNodeWithMarkup(node, markup);
-    ReactDOMNodeCache.purgeEntireCache();
-  },
-
-  /**
-   * TODO: We only actually *need* to purge the cache when we remove elements.
-   *       Detect if any elements were removed instead of blindly purging.
-   */
-  manageChildrenByParentID: function(parentID, domOperations) {
-    var parent = ReactDOMNodeCache.getCachedNodeByID(parentID);
-    DOMChildrenOperations.manageChildren(parent, domOperations);
-    ReactDOMNodeCache.purgeEntireCache();
-  },
-
-  setTextNodeValueAtIndexByParentID: function(parentID, index, value) {
-    var parent = ReactDOMNodeCache.getCachedNodeByID(parentID);
-    DOMChildrenOperations.setTextNodeValueAtIndex(parent, index, value);
-  }
-
-};
-
-module.exports = ReactDOMIDOperations;
diff --git a/React/ReactDOMNodeCache.js b/React/ReactDOMNodeCache.js
deleted file mode 100644
index a3309f2d4d..0000000000
--- a/React/ReactDOMNodeCache.js
+++ /dev/null
@@ -1,52 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactDOMNodeCache
- */
-
-"use strict";
-
-var ReactMount = require("./ReactMount");
-
-var nodeCache = {};
-
-/**
- * DOM node cache only intended for use by React. Placed into a shared module so
- * that both read and write utilities may benefit from a shared cache.
- */
-var ReactDOMNodeCache = {
-  /**
-   * Releases fast id lookups (node/style cache). This implementation is
-   * aggressive with purging because the bookkeeping associated with doing fine
-   * grained deleted from the cache may outweight the benefits of the cache. The
-   * heuristic that should be used to purge is 'any time anything is deleted'.
-   * Typically this means that a large amount of content is being replaced and
-   * several elements would need purging regardless. It's also a time when an
-   * application is likely not in the middle of a "smooth operation" (such as
-   * animating/scrolling).
-   */
-  purgeEntireCache: function() {
-    nodeCache = {};
-    return nodeCache;
-  },
-  getCachedNodeByID: function(id) {
-    return nodeCache[id] ||
-      (nodeCache[id] =
-        document.getElementById(id) ||
-        ReactMount.findReactRenderedDOMNodeSlow(id));
-  }
-};
-
-module.exports = ReactDOMNodeCache;
diff --git a/React/ReactDefaultInjection.js b/React/ReactDefaultInjection.js
deleted file mode 100644
index 9cd3aef190..0000000000
--- a/React/ReactDefaultInjection.js
+++ /dev/null
@@ -1,59 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactDefaultInjection
- */
-
-"use strict";
-
-var ReactDOM = require("./ReactDOM");
-var ReactDOMForm = require("./ReactDOMForm");
-
-var DefaultEventPluginOrder = require("./DefaultEventPluginOrder");
-var EnterLeaveEventPlugin = require("./EnterLeaveEventPlugin");
-var EventPluginHub = require("./EventPluginHub");
-var ReactInstanceHandles = require("./ReactInstanceHandles");
-var SimpleEventPlugin = require("./SimpleEventPlugin");
-
-function inject() {
-  /**
-   * Inject module for resolving DOM hierarchy and plugin ordering.
-   */
-  EventPluginHub.injection.injectEventPluginOrder(DefaultEventPluginOrder);
-  EventPluginHub.injection.injectInstanceHandle(ReactInstanceHandles);
-
-  /**
-   * Two important event plugins included by default (without having to require
-   * them).
-   */
-  EventPluginHub.injection.injectEventPluginsByName({
-    'SimpleEventPlugin': SimpleEventPlugin,
-    'EnterLeaveEventPlugin': EnterLeaveEventPlugin
-  });
-
-  /*
-   * This is a bit of a hack. We need to override the <form> element
-   * to be a composite component because IE8 does not bubble or capture
-   * submit to the top level. In order to make this work with our
-   * dependency graph we need to inject it here.
-   */
-  ReactDOM.injection.injectComponentClasses({
-    form: ReactDOMForm
-  });
-}
-
-module.exports = {
-  inject: inject
-};
diff --git a/React/ReactEvent.js b/React/ReactEvent.js
deleted file mode 100644
index c77534ad4e..0000000000
--- a/React/ReactEvent.js
+++ /dev/null
@@ -1,321 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactEvent
- */
-
-"use strict";
-
-var BrowserEnv = require("./BrowserEnv");
-var EventConstants = require("./EventConstants");
-var EventPluginHub = require("./EventPluginHub");
-var ExecutionEnvironment = require("./ExecutionEnvironment");
-var NormalizedEventListener = require("./NormalizedEventListener");
-
-var invariant = require("./invariant");
-var isEventSupported = require("./isEventSupported");
-
-var registrationNames = EventPluginHub.registrationNames;
-var topLevelTypes = EventConstants.topLevelTypes;
-var listen = NormalizedEventListener.listen;
-var capture = NormalizedEventListener.capture;
-
-/**
- * `ReactEvent` is used to attach top-level event listeners. For example:
- *
- *   ReactEvent.putListener('myID', 'onClick', myFunction);
- *
- * This would allocate a "registration" of `('onClick', myFunction)` on 'myID'.
- */
-
-/**
- * Overview of React and the event system:
- *
- *                    .
- * +-------------+    .
- * |    DOM      |    .
- * +-------------+    .                          +-----------+
- *       +            .                +--------+|SimpleEvent|
- *       |            .                |         |Plugin     |
- * +-----|-------+    .                v         +-----------+
- * |     |       |    .     +--------------+                    +------------+
- * |     +------------.---->|EventPluginHub|                    |    Event   |
- * |             |    .     |              |     +-----------+  | Propagators|
- * | ReactEvent  |    .     |              |     |TapEvent   |  |------------|
- * |             |    .     |              |<---+|Plugin     |  |other plugin|
- * |     +------------.---------+          |     +-----------+  |  utilities |
- * |     |       |    .     |   |          |                    +------------+
- * |     |       |    .     +---|----------+
- * |     |       |    .         |       ^        +-----------+
- * |     |       |    .         |       |        |Enter/Leave|
- * +-----| ------+    .         |       +-------+|Plugin     |
- *       |            .         v                +-----------+
- *       +            .      +--------+
- * +-------------+    .      |callback|
- * | application |    .      |registry|
- * |-------------|    .      +--------+
- * |             |    .
- * |             |    .
- * |             |    .
- * |             |    .
- * +-------------+    .
- *                    .
- *    React Core      .  General Purpose Event Plugin System
- */
-
-/**
- * We listen for bubbled touch events on the document object.
- *
- * Firefox v8.01 (and possibly others) exhibited strange behavior when mounting
- * `onmousemove` events at some node that was not the document element. The
- * symptoms were that if your mouse is not moving over something contained
- * within that mount point (for example on the background) the top-level
- * listeners for `onmousemove` won't be called. However, if you register the
- * `mousemove` on the document object, then it will of course catch all
- * `mousemove`s. This along with iOS quirks, justifies restricting top-level
- * listeners to the document object only, at least for these movement types of
- * events and possibly all events.
- *
- * @see http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
- *
- * Also, `keyup`/`keypress`/`keydown` do not bubble to the window on IE, but
- * they bubble to document.
- *
- * @see http://www.quirksmode.org/dom/events/keys.html.
- */
-
-var _isListening = false;
-
-var EVENT_LISTEN_MISUSE;
-var WORKER_DISABLE;
-
-if (true) {
-  EVENT_LISTEN_MISUSE =
-    'You must register listeners at the top of the document, only once - ' +
-    'and only in the main UI thread of a browser - if you are attempting ' +
-    'listen in a worker, the framework is probably doing something wrong ' +
-    'and you should report this immediately.';
-  WORKER_DISABLE =
-    'Cannot disable event listening in Worker thread. This is likely a ' +
-    'bug in the framework. Please report immediately.';
-}
-
-
-/**
- * Traps top-level events that bubble. Delegates to the main dispatcher
- * `handleTopLevel` after performing some basic normalization via
- * `TopLevelCallbackCreator.createTopLevelCallback`.
- */
-function trapBubbledEvent(topLevelType, handlerBaseName, onWhat) {
-  listen(
-    onWhat,
-    handlerBaseName,
-    ReactEvent.TopLevelCallbackCreator.createTopLevelCallback(topLevelType)
-  );
-}
-
-/**
- * Traps a top-level event by using event capturing.
- */
-function trapCapturedEvent(topLevelType, handlerBaseName, onWhat) {
-  capture(
-    onWhat,
-    handlerBaseName,
-    ReactEvent.TopLevelCallbackCreator.createTopLevelCallback(topLevelType)
-  );
-}
-
-/**
- * Listens to document scroll and window resize events that may change the
- * document scroll values. We store those results so as to discourage
- * application code from asking the DOM itself which could trigger additional
- * reflows.
- */
-function registerDocumentScrollListener() {
-  listen(window, 'scroll', function(nativeEvent) {
-    if (nativeEvent.target === window) {
-      BrowserEnv.refreshAuthoritativeScrollValues();
-    }
-  });
-}
-
-function registerDocumentResizeListener() {
-  listen(window, 'resize', function(nativeEvent) {
-    if (nativeEvent.target === window) {
-      BrowserEnv.refreshAuthoritativeScrollValues();
-    }
-  });
-}
-
-/**
- * Summary of `ReactEvent` event handling:
- *
- *  - We trap low level 'top-level' events.
- *
- *  - We dedupe cross-browser event names into these 'top-level types' so that
- *    `DOMMouseScroll` or `mouseWheel` both become `topMouseWheel`.
- *
- *  - At this point we have native browser events with the top-level type that
- *    was used to catch it at the top-level.
- *
- *  - We continuously stream these native events (and their respective top-level
- *    types) to the event plugin system `EventPluginHub` and ask the plugin
- *    system if it was able to extract `AbstractEvent` objects. `AbstractEvent`
- *    objects are the events that applications actually deal with - they are not
- *    native browser events but cross-browser wrappers.
- *
- *  - When returning the `AbstractEvent` objects, `EventPluginHub` will make
- *    sure each abstract event is annotated with "dispatches", which are the
- *    sequence of listeners (and IDs) that care about the event.
- *
- *  - These `AbstractEvent` objects are fed back into the event plugin system,
- *    which in turn executes these dispatches.
- *
- * @private
- */
-function listenAtTopLevel(touchNotMouse) {
-  invariant(
-    !_isListening,
-    'listenAtTopLevel(...): Cannot setup top-level listener more than once.'
-  );
-  var mountAt = document;
-
-  registerDocumentScrollListener();
-  registerDocumentResizeListener();
-  trapBubbledEvent(topLevelTypes.topMouseOver, 'mouseover', mountAt);
-  trapBubbledEvent(topLevelTypes.topMouseDown, 'mousedown', mountAt);
-  trapBubbledEvent(topLevelTypes.topMouseUp, 'mouseup', mountAt);
-  trapBubbledEvent(topLevelTypes.topMouseMove, 'mousemove', mountAt);
-  trapBubbledEvent(topLevelTypes.topMouseOut, 'mouseout', mountAt);
-  trapBubbledEvent(topLevelTypes.topClick, 'click', mountAt);
-  trapBubbledEvent(topLevelTypes.topDoubleClick, 'dblclick', mountAt);
-  trapBubbledEvent(topLevelTypes.topMouseWheel, 'mousewheel', mountAt);
-  if (touchNotMouse) {
-    trapBubbledEvent(topLevelTypes.topTouchStart, 'touchstart', mountAt);
-    trapBubbledEvent(topLevelTypes.topTouchEnd, 'touchend', mountAt);
-    trapBubbledEvent(topLevelTypes.topTouchMove, 'touchmove', mountAt);
-    trapBubbledEvent(topLevelTypes.topTouchCancel, 'touchcancel', mountAt);
-  }
-  trapBubbledEvent(topLevelTypes.topKeyUp, 'keyup', mountAt);
-  trapBubbledEvent(topLevelTypes.topKeyPress, 'keypress', mountAt);
-  trapBubbledEvent(topLevelTypes.topKeyDown, 'keydown', mountAt);
-  trapBubbledEvent(topLevelTypes.topChange, 'change', mountAt);
-  trapBubbledEvent(
-    topLevelTypes.topDOMCharacterDataModified,
-    'DOMCharacterDataModified',
-    mountAt
-  );
-
-  // Firefox needs to capture a different mouse scroll event.
-  // @see http://www.quirksmode.org/dom/events/tests/scroll.html
-  trapBubbledEvent(topLevelTypes.topMouseWheel, 'DOMMouseScroll', mountAt);
-  // IE < 9 doesn't support capturing so just trap the bubbled event there.
-  if (isEventSupported('scroll', true)) {
-    trapCapturedEvent(topLevelTypes.topScroll, 'scroll', mountAt);
-  } else {
-    trapBubbledEvent(topLevelTypes.topScroll, 'scroll', window);
-  }
-
-  if (isEventSupported('focus', true)) {
-    trapCapturedEvent(topLevelTypes.topFocus, 'focus', mountAt);
-    trapCapturedEvent(topLevelTypes.topBlur, 'blur', mountAt);
-  } else if (isEventSupported('focusin')) {
-    // IE has `focusin` and `focusout` events which bubble.
-    // @see http://www.quirksmode.org/blog/archives/2008/04/delegating_the.html
-    trapBubbledEvent(topLevelTypes.topFocus, 'focusin', mountAt);
-    trapBubbledEvent(topLevelTypes.topBlur, 'focusout', mountAt);
-  }
-}
-
-/**
- * This is the heart of `ReactEvent`. It simply streams the top-level native
- * events to `EventPluginHub`.
- *
- * @param {object} topLevelType Record from `EventConstants`.
- * @param {Event} nativeEvent A Standard Event with fixed `target` property.
- * @param {DOMElement} renderedTarget Element of interest to the framework.
- * @param {string} renderedTargetID string ID of `renderedTarget`.
- * @internal
- */
-function handleTopLevel(
-    topLevelType,
-    nativeEvent,
-    renderedTargetID,
-    renderedTarget) {
-  var abstractEvents = EventPluginHub.extractAbstractEvents(
-    topLevelType,
-    nativeEvent,
-    renderedTargetID,
-    renderedTarget
-  );
-
-  // The event queue being processed in the same cycle allows preventDefault.
-  EventPluginHub.enqueueAbstractEvents(abstractEvents);
-  EventPluginHub.processAbstractEventQueue();
-}
-
-function setEnabled(enabled) {
-  invariant(
-    ExecutionEnvironment.canUseDOM,
-    'setEnabled(...): Cannot toggle event listening in a Worker thread. This ' +
-    'is likely a bug in the framework. Please report immediately.'
-  );
-  ReactEvent.TopLevelCallbackCreator.setEnabled(enabled);
-}
-
-function isEnabled() {
-  return ReactEvent.TopLevelCallbackCreator.isEnabled();
-}
-
-/**
- * Ensures that top-level event delegation listeners are listening at `mountAt`.
- * There are issues with listening to both touch events and mouse events on the
- * top-level, so we make the caller choose which one to listen to. (If there's a
- * touch top-level listeners, anchors don't receive clicks for some reason, and
- * only in some cases).
- *
- * @param {boolean} touchNotMouse Listen to touch events instead of mouse.
- * @param {object} TopLevelCallbackCreator Module that can create top-level
- *   callback handlers.
- * @internal
- */
-function ensureListening(touchNotMouse, TopLevelCallbackCreator) {
-  invariant(
-    ExecutionEnvironment.canUseDOM,
-    'ensureListening(...): Cannot toggle event listening in a Worker thread. ' +
-    'This is likely a bug in the framework. Please report immediately.'
-  );
-  if (!_isListening) {
-    ReactEvent.TopLevelCallbackCreator = TopLevelCallbackCreator;
-    listenAtTopLevel(touchNotMouse);
-    _isListening = true;
-  }
-}
-
-var ReactEvent = {
-  TopLevelCallbackCreator: null, // Injectable callback creator.
-  handleTopLevel: handleTopLevel,
-  setEnabled: setEnabled,
-  isEnabled: isEnabled,
-  ensureListening: ensureListening,
-  registrationNames: registrationNames,
-  putListener: EventPluginHub.putListener,
-  getListener: EventPluginHub.getListener,
-  deleteAllListeners: EventPluginHub.deleteAllListeners,
-  trapBubbledEvent: trapBubbledEvent,
-  trapCapturedEvent: trapCapturedEvent
-};
-
-module.exports = ReactEvent;
diff --git a/React/ReactEventTopLevelCallback.js b/React/ReactEventTopLevelCallback.js
deleted file mode 100644
index c5e93ce9f6..0000000000
--- a/React/ReactEventTopLevelCallback.js
+++ /dev/null
@@ -1,74 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactEventTopLevelCallback
- */
-
-"use strict";
-
-var ExecutionEnvironment = require("./ExecutionEnvironment");
-var ReactEvent = require("./ReactEvent");
-var ReactInstanceHandles = require("./ReactInstanceHandles");
-
-var getDOMNodeID = require("./getDOMNodeID");
-
-var _topLevelListenersEnabled = true;
-
-var ReactEventTopLevelCallback = {
-
-  /**
-   * @param {boolean} enabled Whether or not all callbacks that have ever been
-   * created with this module should be enabled.
-   */
-  setEnabled: function(enabled) {
-    _topLevelListenersEnabled = !!enabled;
-  },
-
-  isEnabled: function() {
-    return _topLevelListenersEnabled;
-  },
-
-  /**
-   * For a given `topLevelType`, creates a callback that could be added as a
-   * listener to the document. That top level callback will simply fix the
-   * native events before invoking `handleTopLevel`.
-   *
-   * - Raw native events cannot be trusted to describe their targets correctly
-   *   so we expect that the argument to the nested function has already been
-   *   fixed.  But the `target` property may not be something of interest to
-   *   React, so we find the most suitable target.  But even at that point, DOM
-   *   Elements (the target ) can't be trusted to describe their IDs correctly
-   *   so we obtain the ID in a reliable manner and pass it to
-   *   `handleTopLevel`. The target/id that we found to be relevant to our
-   *   framework are called `renderedTarget`/`renderedTargetID` respectively.
-   */
-  createTopLevelCallback: function(topLevelType) {
-    return function(fixedNativeEvent) {
-      if (!_topLevelListenersEnabled) {
-        return;
-      }
-      var renderedTarget = ReactInstanceHandles.getFirstReactDOM(
-        fixedNativeEvent.target
-      ) || ExecutionEnvironment.global;
-      var renderedTargetID = getDOMNodeID(renderedTarget);
-      var event = fixedNativeEvent;
-      var target = renderedTarget;
-      ReactEvent.handleTopLevel(topLevelType, event, renderedTargetID, target);
-    };
-  }
-
-};
-
-module.exports = ReactEventTopLevelCallback;
diff --git a/React/ReactInputSelection.js b/React/ReactInputSelection.js
deleted file mode 100644
index 2abd7ab6f0..0000000000
--- a/React/ReactInputSelection.js
+++ /dev/null
@@ -1,180 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactInputSelection
- */
-
-"use strict";
-
-// It is not safe to read the document.activeElement property in IE if there's
-// nothing focused.
-function getActiveElement() {
-  try {
-    return document.activeElement;
-  } catch (e) {
-  }
-}
-
-/**
- * @ReactInputSelection: React input selection module. Based on Selection.js,
- * but modified to be suitable for react and has a couple of bug fixes (doesn't
- * assume buttons have range selections allowed).
- * Input selection module for React.
- */
-var ReactInputSelection = {
-
-  hasSelectionCapabilities: function(elem) {
-    return elem && (
-      (elem.nodeName === 'INPUT' && elem.type === 'text') ||
-      elem.nodeName === 'TEXTAREA' ||
-      elem.contentEditable === 'true'
-    );
-  },
-
-  getSelectionInformation: function() {
-    var focusedElem = getActiveElement();
-    return {
-      focusedElem: focusedElem,
-      selectionRange:
-          ReactInputSelection.hasSelectionCapabilities(focusedElem) ?
-          ReactInputSelection.getSelection(focusedElem) :
-          null
-    };
-  },
-
-  /**
-   * @restoreSelection: If any selection information was potentially lost,
-   * restore it. This is useful when performing operations that could remove dom
-   * nodes and place them back in, resulting in focus being lost.
-   */
-  restoreSelection: function(priorSelectionInformation) {
-    var curFocusedElem = getActiveElement();
-    var priorFocusedElem = priorSelectionInformation.focusedElem;
-    var priorSelectionRange = priorSelectionInformation.selectionRange;
-    if (curFocusedElem !== priorFocusedElem &&
-        document.getElementById(priorFocusedElem.id)) {
-      if (ReactInputSelection.hasSelectionCapabilities(priorFocusedElem)) {
-        ReactInputSelection.setSelection(
-          priorFocusedElem,
-          priorSelectionRange
-        );
-      }
-      priorFocusedElem.focus();
-    }
-  },
-
-  /**
-   * @getSelection: Gets the selection bounds of a textarea or input.
-   * -@input: Look up selection bounds of this input or textarea
-   * -@return {start: selectionStart, end: selectionEnd}
-   */
-  getSelection: function(input) {
-    var range;
-    if (input.contentEditable === 'true' && window.getSelection) {
-      range = window.getSelection().getRangeAt(0);
-      var commonAncestor = range.commonAncestorContainer;
-      if (commonAncestor && commonAncestor.nodeType === 3) {
-        commonAncestor = commonAncestor.parentNode;
-      }
-      if (commonAncestor !== input) {
-        return {start: 0, end: 0};
-      } else {
-        return {start: range.startOffset, end: range.endOffset};
-      }
-    }
-
-    if (!document.selection) {
-      // Mozilla, Safari, etc.
-      return {start: input.selectionStart, end: input.selectionEnd};
-    }
-
-    range = document.selection.createRange();
-    if (range.parentElement() !== input) {
-      // There can only be one selection per document in IE, so if the
-      // containing element of the document's selection isn't our text field,
-      // our text field must have no selection.
-      return {start: 0, end: 0};
-    }
-
-    var length = input.value.length;
-
-    if (input.nodeName === 'INPUT') {
-      return {
-        start: -range.moveStart('character', -length),
-        end: -range.moveEnd('character', -length)
-      };
-    } else {
-      var range2 = range.duplicate();
-      range2.moveToElementText(input);
-      range2.setEndPoint('StartToEnd', range);
-      var end = length - range2.text.length;
-      range2.setEndPoint('StartToStart', range);
-      return {
-        start: length - range2.text.length,
-        end:   end
-      };
-    }
-  },
-
-  /**
-   * @setSelection: Sets the selection bounds of a textarea or input and focuses
-   * the input.
-   * -@input     Set selection bounds of this input or textarea
-   * -@rangeObj Object of same form that is returned from get*
-   */
-  setSelection: function(input, rangeObj) {
-    var range;
-    var start = rangeObj.start;
-    var end = rangeObj.end;
-    if (typeof end === 'undefined') {
-      end = start;
-    }
-    if (document.selection) {
-      // IE is inconsistent about character offsets when it comes to carriage
-      // returns, so we need to manually take them into account
-      if (input.tagName === 'TEXTAREA') {
-        var cr_before =
-          (input.value.slice(0, start).match(/\r/g) || []).length;
-        var cr_inside =
-          (input.value.slice(start, end).match(/\r/g) || []).length;
-        start -= cr_before;
-        end -= cr_before + cr_inside;
-      }
-      range = input.createTextRange();
-      range.collapse(true);
-      range.moveStart('character', start);
-      range.moveEnd('character', end - start);
-      range.select();
-    } else {
-      if (input.contentEditable === 'true') {
-        if (input.childNodes.length === 1) {
-          range = document.createRange();
-          range.setStart(input.childNodes[0], start);
-          range.setEnd(input.childNodes[0], end);
-          var sel = window.getSelection();
-          sel.removeAllRanges();
-          sel.addRange(range);
-        }
-      } else {
-        input.selectionStart = start;
-        input.selectionEnd = Math.min(end, input.value.length);
-        input.focus();
-      }
-    }
-  }
-
-};
-
-module.exports = ReactInputSelection;
diff --git a/React/ReactInstanceHandles.js b/React/ReactInstanceHandles.js
deleted file mode 100644
index 784e8ce5bc..0000000000
--- a/React/ReactInstanceHandles.js
+++ /dev/null
@@ -1,326 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactInstanceHandles
- */
-
-"use strict";
-
-var getDOMNodeID = require("./getDOMNodeID");
-var invariant = require("./invariant");
-
-var SEPARATOR = '.';
-var SEPARATOR_LENGTH = SEPARATOR.length;
-
-/**
- * Maximum depth of traversals before we consider the possibility of a bad ID.
- */
-var MAX_TREE_DEPTH = 100;
-
-/**
- * Checks if a character in the supplied ID is a separator or the end.
- *
- * @param {string} id A React DOM ID.
- * @param {number} index Index of the character to check.
- * @return {boolean} True if the character is a separator or end of the ID.
- * @private
- */
-function isMarker(id, index) {
-  return id.charAt(index) === SEPARATOR || index === id.length;
-}
-
-/**
- * Checks if the supplied string is a valid React DOM ID.
- *
- * @param {string} id A React DOM ID, maybe.
- * @return {boolean} True if the string is a valid React DOM ID.
- * @private
- */
-function isValidID(id) {
-  return id === '' || (
-    id.charAt(0) === SEPARATOR && id.charAt(id.length - 1) !== SEPARATOR
-  );
-}
-
-/**
- * True if the supplied `node` is rendered by React.
- *
- * @param {DOMElement} node DOM Element to check.
- * @return {boolean} True if the DOM Element appears to be rendered by React.
- * @private
- */
-function isRenderedByReact(node) {
-  var id = getDOMNodeID(node);
-  return id && id.charAt(0) === SEPARATOR;
-}
-
-/**
- * Gets the parent ID of the supplied React DOM ID, `id`.
- *
- * @param {string} id ID of a component.
- * @return {string} ID of the parent, or an empty string.
- * @private
- */
-function parentID(id) {
-  return id ? id.substr(0, id.lastIndexOf(SEPARATOR)) : '';
-}
-
-/**
- * Traverses the parent path between two IDs (either up or down). The IDs must
- * not be the same, and there must exist a parent path between them.
- *
- * @param {?string} start ID at which to start traversal.
- * @param {?string} stop ID at which to end traversal.
- * @param {function} cb Callback to invoke each ID with.
- * @param {?boolean} skipFirst Whether or not to skip the first node.
- * @param {?boolean} skipLast Whether or not to skip the last node.
- * @private
- */
-function traverseParentPath(start, stop, cb, arg, skipFirst, skipLast) {
-  start = start || '';
-  stop = stop || '';
-  invariant(
-    start !== stop,
-    'traverseParentPath(...): Cannot traverse from and to the same ID, `%s`.',
-    start
-  );
-  var ancestorID = ReactInstanceHandles.getFirstCommonAncestorID(start, stop);
-  var traverseUp = ancestorID === stop;
-  invariant(
-    traverseUp || ancestorID === start,
-    'traverseParentPath(%s, %s, ...): Cannot traverse from two IDs that do ' +
-    'not have a parent path.',
-    start,
-    stop
-  );
-  // Traverse from `start` to `stop` one depth at a time.
-  var depth = 0;
-  var traverse = traverseUp ? parentID : ReactInstanceHandles.nextDescendantID;
-  for (var id = start; /* until break */; id = traverse(id, stop)) {
-    if ((!skipFirst || id !== start) && (!skipLast || id !== stop)) {
-      cb(id, traverseUp, arg);
-    }
-    if (id === stop) {
-      // Only break //after// visiting `stop`.
-      break;
-    }
-    invariant(
-      depth++ < MAX_TREE_DEPTH,
-      'traverseParentPath(%s, %s, ...): Detected an infinite loop while ' +
-      'traversing the React DOM ID tree. This may be due to malformed IDs: %s',
-      start, stop
-    );
-  }
-}
-
-/**
- * Manages the IDs assigned to DOM representations of React components. This
- * uses a specific scheme in order to traverse the DOM efficiently (e.g. in
- * order to simulate events).
- *
- * @internal
- */
-var ReactInstanceHandles = {
-
-  separator: SEPARATOR,
-
-  /**
-   * Traverses up the ancestors of the supplied node to find a node that is a
-   * DOM representation of a React component.
-   *
-   * @param {DOMElement} node
-   * @return {?DOMElement}
-   * @internal
-   */
-  getFirstReactDOM: function(node) {
-    var current = node;
-    while (current && current.parentNode !== current) {
-      if (isRenderedByReact(current)) {
-        return current;
-      }
-      current = current.parentNode;
-    }
-    return null;
-  },
-
-  /**
-   * Finds a node with the supplied `id` inside of the supplied `ancestorNode`.
-   * Exploits the ID naming scheme to perform the search quickly.
-   *
-   * @param {DOMElement} ancestorNode Search from this root.
-   * @pararm {string} id ID of the DOM representation of the component.
-   * @return {?DOMElement} DOM element with the supplied `id`, if one exists.
-   * @internal
-   */
-  findComponentRoot: function(ancestorNode, id) {
-    var child = ancestorNode.firstChild;
-    while (child) {
-      if (id === child.id) {
-        return child;
-      } else if (id.indexOf(child.id) === 0) {
-        return ReactInstanceHandles.findComponentRoot(child, id);
-      }
-      child = child.nextSibling;
-    }
-    // Effectively: return null;
-  },
-
-  /**
-   * 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 two IDs that immediately preceded a "marker" in both strings.
-   *
-   * @param {string} oneID
-   * @param {string} twoID
-   * @return {string} Nearest common ancestor ID, or the empty string if none.
-   * @internal
-   */
-  getFirstCommonAncestorID: function(oneID, twoID) {
-    var minLength = Math.min(oneID.length, twoID.length);
-    if (minLength === 0) {
-      return '';
-    }
-    var lastCommonMarkerIndex = 0;
-    // Use `<=` to traverse until the "EOL" of the shorter string.
-    for (var i = 0; i <= minLength; i++) {
-      if (isMarker(oneID, i) && isMarker(twoID, i)) {
-        lastCommonMarkerIndex = i;
-      } else if (oneID.charAt(i) !== twoID.charAt(i)) {
-        break;
-      }
-    }
-    var longestCommonID = oneID.substr(0, lastCommonMarkerIndex);
-    invariant(
-      isValidID(longestCommonID),
-      'getFirstCommonAncestorID(%s, %s): Expected a valid React DOM ID: %s',
-      oneID,
-      twoID,
-      longestCommonID
-    );
-    return longestCommonID;
-  },
-  /**
-   * Creates a DOM ID to use when mounting React components.
-   *
-   * @param {number} mountPointCount The count of React renders so far.
-   * @return {string} React root ID.
-   * @internal
-   */
-  getReactRootID: function(mountPointCount) {
-    return '.reactRoot[' + mountPointCount + ']';
-  },
-
-  /**
-   * Gets the DOM ID of the React component that is the root of the tree that
-   * contains the React component with the supplied DOM ID.
-   *
-   * @param {string} id DOM ID of a React component.
-   * @return {string} DOM ID of the React component that is the root.
-   * @internal
-   */
-  getReactRootIDFromNodeID: function(id) {
-    var regexResult = /\.reactRoot\[[^\]]+\]/.exec(id);
-    return regexResult && regexResult[0];
-  },
-
-  /**
-   * Traverses the ID hierarchy and invokes the supplied `cb` on any IDs that
-   * should would receive a `mouseEnter` or `mouseLeave` event.
-   *
-   * NOTE: Does not invoke the callback on the nearest common ancestor because
-   * nothing "entered" or "left" that element.
-   *
-   * @param {string} leaveID ID being left.
-   * @param {string} enterID ID being entered.
-   * @param {function} cb Callback to invoke on each entered/left ID.
-   * @param {*} upArg Argument to invoke the callback with on left IDs.
-   * @param {*} downArg Argument to invoke the callback with on entered IDs.
-   * @internal
-   */
-  traverseEnterLeave: function(leaveID, enterID, cb, upArg, downArg) {
-    var longestCommonID = ReactInstanceHandles.getFirstCommonAncestorID(
-      leaveID,
-      enterID
-    );
-    if (longestCommonID !== leaveID) {
-      traverseParentPath(leaveID, longestCommonID, cb, upArg, false, true);
-    }
-    if (longestCommonID !== enterID) {
-      traverseParentPath(longestCommonID, enterID, cb, downArg, true, false);
-    }
-  },
-
-  /**
-   * Simulates the traversal of a two-phase, capture/bubble event dispatch.
-   *
-   * NOTE: This traversal happens on IDs without touching the DOM.
-   *
-   * @param {string} targetID ID of the target node.
-   * @param {function} cb Callback to invoke.
-   * @param {*} arg Argument to invoke the callback with.
-   * @internal
-   */
-  traverseTwoPhase: function(targetID, cb, arg) {
-    if (targetID) {
-      traverseParentPath('', targetID, cb, arg, true, false);
-      traverseParentPath(targetID, '', cb, arg, false, true);
-    }
-  },
-
-  /**
-   * Gets the next DOM ID on the tree path from the supplied `ancestorID` to the
-   * supplied `destinationID`. If they are equal, the ID is returned.
-   *
-   * @param {string} ancestorID ID of an ancestor node of `destinationID`.
-   * @param {string} destinationID ID of the destination node.
-   * @return {string} Next ID on the path from `ancestorID` to `destinationID`.
-   * @internal
-   */
-  nextDescendantID: function(ancestorID, destinationID) {
-    invariant(
-      isValidID(ancestorID) && isValidID(destinationID),
-      'nextDescendantID(%s, %s): Received an invalid React DOM ID.',
-      ancestorID,
-      destinationID
-    );
-    var longestCommonID = ReactInstanceHandles.getFirstCommonAncestorID(
-      ancestorID,
-      destinationID
-    );
-    invariant(
-      longestCommonID === ancestorID,
-      'nextDescendantID(...): React has made an invalid assumption about the ' +
-      'DOM hierarchy. Expected `%s` to be an ancestor of `%s`.',
-      ancestorID,
-      destinationID
-    );
-    if (ancestorID === destinationID) {
-      return ancestorID;
-    }
-    // Skip over the ancestor and the immediate separator. Traverse until we hit
-    // another separator or we reach the end of `destinationID`.
-    var start = ancestorID.length + SEPARATOR_LENGTH;
-    for (var i = start; i < destinationID.length; i++) {
-      if (isMarker(destinationID, i)) {
-        break;
-      }
-    }
-    return destinationID.substr(0, i);
-  }
-
-};
-
-module.exports = ReactInstanceHandles;
diff --git a/React/ReactMount.js b/React/ReactMount.js
deleted file mode 100644
index 865258201e..0000000000
--- a/React/ReactMount.js
+++ /dev/null
@@ -1,232 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactMount
- */
-
-"use strict";
-
-var ReactEvent = require("./ReactEvent");
-var ReactInstanceHandles = require("./ReactInstanceHandles");
-var ReactEventTopLevelCallback = require("./ReactEventTopLevelCallback");
-
-var $ = require("./$");
-
-var globalMountPointCounter = 0;
-
-/** Mapping from reactRoot DOM ID to React component instance. */
-var instanceByReactRootID = {};
-
-/** Mapping from reactRoot DOM ID to `container` nodes. */
-var containersByReactRootID = {};
-
-/**
- * @param {DOMElement} container DOM element that may contain a React component.
- * @return {?string} A "reactRoot" ID, if a React component is rendered.
- */
-function getReactRootID(container) {
-  return container.firstChild && container.firstChild.id;
-}
-
-/**
- * Mounting is the process of initializing a React component by creatings its
- * representative DOM elements and inserting them into a supplied `container`.
- * Any prior content inside `container` is destroyed in the process.
- *
- *   ReactMount.renderComponent(component, $('container'));
- *
- *   <div id="container">         <-- Supplied `container`.
- *     <div id=".reactRoot[3]">   <-- Rendered reactRoot of React component.
- *       // ...
- *     </div>
- *   </div>
- *
- * Inside of `container`, the first element rendered is the "reactRoot".
- */
-var ReactMount = {
-
-  /** Time spent generating markup. */
-  totalInstantiationTime: 0,
-
-  /** Time spent inserting markup into the DOM. */
-  totalInjectionTime: 0,
-
-  /** Whether support for touch events should be initialized. */
-  useTouchEvents: false,
-
-  /**
-   * This is a hook provided to support rendering React components while
-   * ensuring that the apparent scroll position of its `container` does not
-   * change.
-   *
-   * @param {DOMElement} container The `container` being rendered into.
-   * @param {function} renderCallback This must be called once to do the render.
-   */
-  scrollMonitor: function(container, renderCallback) {
-    renderCallback();
-  },
-
-  /**
-   * Ensures tht the top-level event delegation listener is set up. This will be
-   * invoked some time before the first time any React component is rendered.
-   *
-   * @param {object} TopLevelCallbackCreator
-   * @private
-   */
-  prepareTopLevelEvents: function(TopLevelCallbackCreator) {
-    ReactEvent.ensureListening(
-      ReactMount.useTouchEvents,
-      TopLevelCallbackCreator
-    );
-  },
-
-  /**
-   * Renders a React component into the DOM in the supplied `container`.
-   *
-   * If the React component was previously rendered into `container`, this will
-   * perform an update on it and only mutate the DOM as necessary to reflect the
-   * latest React component.
-   *
-   * @param {ReactComponent} nextComponent Component instance to render.
-   * @param {DOMElement} container DOM element to render into.
-   * @return {ReactComponent} Component instance rendered in `container`.
-   */
-  renderComponent: function(nextComponent, container) {
-    var prevComponent = instanceByReactRootID[getReactRootID(container)];
-    if (prevComponent) {
-      var nextProps = nextComponent.props;
-      ReactMount.scrollMonitor(container, function() {
-        prevComponent.replaceProps(nextProps);
-      });
-      return prevComponent;
-    }
-
-    ReactMount.prepareTopLevelEvents(ReactEventTopLevelCallback);
-
-    var reactRootID = ReactMount.registerContainer(container);
-    instanceByReactRootID[reactRootID] = nextComponent;
-    nextComponent.mountComponentIntoNode(reactRootID, container);
-    return nextComponent;
-  },
-
-  /**
-   * Creates a function that accepts a `container` and renders the supplied
-   * React component instance into it.
-   *
-   *   var renderInto = ReactMount.createComponentRenderer(component);
-   *   // ...
-   *   var component = renderInto($('container'));
-   *
-   * @param {ReactComponent} component Component instance to render.
-   * @return {function(DOMElement): ReactComponent}
-   */
-  createComponentRenderer: function(component) {
-    return function(container) {
-      return ReactMount.renderComponent(component, container);
-    };
-  },
-
-  /**
-   * Constructs a component instance of `constructor` with `initialProps` and
-   * renders it into the supplied `container`.
-   *
-   * @param {function} constructor React component constructor.
-   * @param {?object} props Initial props of the component instance.
-   * @param {DOMElement} container DOM element to render into.
-   * @return {ReactComponent} Component instance rendered in `container`.
-   */
-  constructAndRenderComponent: function(constructor, props, container) {
-    return ReactMount.renderComponent(constructor(props), container);
-  },
-
-  /**
-   * Constructs a component instance of `constructor` with `initialProps` and
-   * renders it into a container node identified by supplied `id`.
-   *
-   * @param {function} componentConstructor React component constructor
-   * @param {?object} props Initial props of the component instance.
-   * @param {string} id ID of the DOM element to render into.
-   * @return {ReactComponent} Component instance rendered in the container node.
-   */
-  constructAndRenderComponentByID: function(constructor, props, id) {
-    return ReactMount.constructAndRenderComponent(constructor, props, $(id));
-  },
-
-  /**
-   * Registers a container node into which React components will be rendered.
-   * This also creates the "reatRoot" ID that will be assigned to the element
-   * rendered within.
-   *
-   * @param {DOMElement} container DOM element to register as a container.
-   * @return {string} The "reactRoot" ID of elements rendered within.
-   */
-  registerContainer: function(container) {
-    var reactRootID = getReactRootID(container);
-    if (reactRootID) {
-      // If one exists, make sure it is a valid "reactRoot" ID.
-      reactRootID = ReactInstanceHandles.getReactRootIDFromNodeID(reactRootID);
-    }
-    if (!reactRootID) {
-      // No valid "reactRoot" ID found, create one.
-      reactRootID = ReactInstanceHandles.getReactRootID(
-        globalMountPointCounter++
-      );
-    }
-    containersByReactRootID[reactRootID] = container;
-    return reactRootID;
-  },
-
-  /**
-   * Unmounts and destroys the React component rendered in the `container`.
-   *
-   * @param {DOMElement} container DOM element containing a React component.
-   */
-  unmountAndReleaseReactRootNode: function(container) {
-    var reactRootID = getReactRootID(container);
-    var component = instanceByReactRootID[reactRootID];
-    // TODO: Consider throwing if no `component` was found.
-    component.unmountComponentFromNode(container);
-    delete instanceByReactRootID[reactRootID];
-    delete containersByReactRootID[reactRootID];
-  },
-
-  /**
-   * Finds the container DOM element that contains React component to which the
-   * supplied DOM `id` belongs.
-   *
-   * @param {string} id The ID of an element rendered by a React component.
-   * @return {?DOMElement} DOM element that contains the `id`.
-   */
-  findReactContainerForID: function(id) {
-    var reatRootID = ReactInstanceHandles.getReactRootIDFromNodeID(id);
-    // TODO: Consider throwing if `id` is not a valid React element ID.
-    return containersByReactRootID[reatRootID];
-  },
-
-  /**
-   * Given the ID of a DOM node rendered by a React component, finds the root
-   * DOM node of the React component.
-   *
-   * @param {string} id ID of a DOM node in the React component.
-   * @return {?DOMElement} Root DOM node of the React component.
-   */
-  findReactRenderedDOMNodeSlow: function(id) {
-    var reactRoot = ReactMount.findReactContainerForID(id);
-    return ReactInstanceHandles.findComponentRoot(reactRoot, id);
-  }
-
-};
-
-module.exports = ReactMount;
diff --git a/React/ReactMultiChild.js b/React/ReactMultiChild.js
deleted file mode 100644
index 6e0b7b32e3..0000000000
--- a/React/ReactMultiChild.js
+++ /dev/null
@@ -1,208 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactMultiChild
- */
-
-"use strict";
-
-var ReactComponent = require("./ReactComponent");
-
-/**
- * Given a `curChild` and `newChild`, determines if `curChild` should be managed
- * as it exists, as opposed to being destroyed and/or replaced.
- * @param {?ReactComponent} curChild
- * @param {?ReactComponent} newChild
- * @return {!boolean} Whether or not `curChild` should be updated with
- * `newChild`'s props
- */
-function shouldManageExisting(curChild, newChild) {
-  return curChild && newChild && curChild.constructor === newChild.constructor;
-}
-
-/**
- * `ReactMultiChild` provides common functionality for components that have
- * multiple children. Standard `ReactCompositeComponent`s do not currently have
- * multiple children. `ReactNativeComponent`s do, however. Other specially
- * reconciled components will also have multiple children. Contains three
- * internally used properties that are used to keep track of state throughout
- * the `updateMultiChild` process.
- *
- * @class ReactMultiChild
- */
-
-/**
- * @lends `ReactMultiChildMixin`.
- */
-var ReactMultiChildMixin = {
-
-  enqueueMarkupAt: function(markup, insertAt) {
-    this.domOperations = this.domOperations || [];
-    this.domOperations.push({insertMarkup: markup, finalIndex: insertAt});
-  },
-
-  enqueueMove: function(originalIndex, finalIndex) {
-    this.domOperations = this.domOperations || [];
-    this.domOperations.push({moveFrom: originalIndex, finalIndex: finalIndex});
-  },
-
-  enqueueUnmountChildByName: function(name, removeChild) {
-    if (ReactComponent.isValidComponent(removeChild)) {
-      this.domOperations = this.domOperations || [];
-      this.domOperations.push({removeAt: removeChild._domIndex});
-      removeChild.unmountComponent && removeChild.unmountComponent();
-      delete this._renderedChildren[name];
-    }
-  },
-
-  /**
-   * Process any pending DOM operations that have been accumulated when updating
-   * the UI. By default, we execute the injected `DOMIDOperations` module's
-   * `manageChildrenByParentID` which does executes the DOM operations without
-   * any animation. It can be used as a reference implementation for special
-   * animation based implementations.
-   *
-   * @abstract
-   */
-  processChildDOMOperationsQueue: function() {
-    if (this.domOperations) {
-      ReactComponent.DOMIDOperations
-        .manageChildrenByParentID(this._rootNodeID, this.domOperations);
-      this.domOperations = null;
-    }
-  },
-
-  unmountMultiChild: function() {
-    var renderedChildren = this._renderedChildren;
-    for (var name in renderedChildren) {
-      if (renderedChildren.hasOwnProperty(name) && renderedChildren[name]) {
-        var renderedChild = renderedChildren[name];
-        renderedChild.unmountComponent && renderedChild.unmountComponent();
-      }
-    }
-    this._renderedChildren = null;
-  },
-
-  /**
-   * Generates markup for a component that holds multiple children. #todo: Allow
-   * all `ReactMultiChildMixin`s to support having arrays of children without a
-   * container node. This current implementation may assume that children exist
-   * at domIndices [0, parentNode.length].
-   *
-   * Has side effects of (likely) causing events to be registered. Also, every
-   * component instance may only be rendered once.
-   *
-   * @param {?Object} children Flattened children object.
-   * @return {!String} The rendered markup.
-   */
-  mountMultiChild: function(children, transaction) {
-    var accum = '';
-    var index = 0;
-    for (var name in children) {
-      var child = children[name];
-      if (children.hasOwnProperty(name) && child) {
-        accum += child.mountComponent(
-          this._rootNodeID + '.' + name,
-          transaction
-        );
-        child._domIndex = index;
-        index++;
-      }
-    }
-    this._renderedChildren = children; // children are in just the right form!
-    this.domOperations = null;
-    return accum;
-  },
-
-  /**
-   * Reconciles new children with old children in three phases.
-   *
-   * - Adds new content while updating existing children that should remain.
-   * - Remove children that are no longer present in the next children.
-   * - As a very last step, moves existing dom structures around.
-   * - (Comment 1) `curChildrenDOMIndex` is the largest index of the current
-   *   rendered children that appears in the next children and did not need to
-   *   be "moved".
-   * - (Comment 2) This is the key insight. If any non-removed child's previous
-   *   index is less than `curChildrenDOMIndex` it must be moved.
-   *
-   * @param {?Object} children Flattened children object.
-   */
-  updateMultiChild: function(nextChildren, transaction) {
-    if (!nextChildren && !this._renderedChildren) {
-      return;
-    } else if (nextChildren && !this._renderedChildren) {
-      this._renderedChildren = {}; // lazily allocate backing store with nothing
-    } else if (!nextChildren && this._renderedChildren) {
-      nextChildren = {};
-    }
-    var rootDomIdDot = this._rootNodeID + '.';
-    var markupBuffer = null;  // Accumulate adjacent new children markup.
-    var numPendingInsert = 0; // How many root nodes are waiting in markupBuffer
-    var loopDomIndex = 0;     // Index of loop through new children.
-    var curChildrenDOMIndex = 0;  // See (Comment 1)
-    for (var name in nextChildren) {
-      if (!nextChildren.hasOwnProperty(name)) {continue;}
-      var curChild = this._renderedChildren[name];
-      var nextChild = nextChildren[name];
-      if (shouldManageExisting(curChild, nextChild)) {
-        if (markupBuffer) {
-          this.enqueueMarkupAt(markupBuffer, loopDomIndex - numPendingInsert);
-          markupBuffer = null;
-        }
-        numPendingInsert = 0;
-        if (curChild._domIndex < curChildrenDOMIndex) { // (Comment 2)
-          this.enqueueMove(curChild._domIndex, loopDomIndex);
-        }
-        curChildrenDOMIndex = Math.max(curChild._domIndex, curChildrenDOMIndex);
-        !nextChild.props.isStatic &&
-          curChild.receiveProps(nextChild.props, transaction);
-        curChild._domIndex = loopDomIndex;
-      } else {
-        if (curChild) {               // !shouldUpdate && curChild => delete
-          this.enqueueUnmountChildByName(name, curChild);
-          curChildrenDOMIndex =
-            Math.max(curChild._domIndex, curChildrenDOMIndex);
-        }
-        if (nextChild) {              // !shouldUpdate && nextChild => insert
-          this._renderedChildren[name] = nextChild;
-          var nextMarkup =
-            nextChild.mountComponent(rootDomIdDot + name, transaction);
-          markupBuffer = markupBuffer ? markupBuffer + nextMarkup : nextMarkup;
-          numPendingInsert++;
-          nextChild._domIndex = loopDomIndex;
-        }
-      }
-      loopDomIndex = nextChild ? loopDomIndex + 1 : loopDomIndex;
-    }
-    if (markupBuffer) {
-      this.enqueueMarkupAt(markupBuffer, loopDomIndex - numPendingInsert);
-    }
-    for (var childName in this._renderedChildren) { // from other direction
-      if (!this._renderedChildren.hasOwnProperty(childName)) { continue; }
-      var child = this._renderedChildren[childName];
-      if (child && !nextChildren[childName]) {
-        this.enqueueUnmountChildByName(childName, child);
-      }
-    }
-    this.processChildDOMOperationsQueue();
-  }
-};
-
-var ReactMultiChild = {
-  Mixin: ReactMultiChildMixin
-};
-
-module.exports = ReactMultiChild;
diff --git a/React/ReactNativeComponent.js b/React/ReactNativeComponent.js
deleted file mode 100644
index 1c0cb2d54e..0000000000
--- a/React/ReactNativeComponent.js
+++ /dev/null
@@ -1,331 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactNativeComponent
- * @typechecks
- */
-
-"use strict";
-
-var CSSPropertyOperations = require("./CSSPropertyOperations");
-var DOMPropertyOperations = require("./DOMPropertyOperations");
-var ReactComponent = require("./ReactComponent");
-var ReactEvent = require("./ReactEvent");
-var ReactMultiChild = require("./ReactMultiChild");
-
-var escapeTextForBrowser = require("./escapeTextForBrowser");
-var flattenChildren = require("./flattenChildren");
-var invariant = require("./invariant");
-var keyOf = require("./keyOf");
-var merge = require("./merge");
-var mixInto = require("./mixInto");
-
-var putListener = ReactEvent.putListener;
-var registrationNames = ReactEvent.registrationNames;
-
-// For quickly matching children type, to test if can be treated as content.
-var CONTENT_TYPES = {'string': true, 'number': true};
-
-var CONTENT = keyOf({content: null});
-var DANGEROUSLY_SET_INNER_HTML = keyOf({dangerouslySetInnerHTML: null});
-var STYLE = keyOf({style: null});
-
-/**
- * @param {?object} props
- */
-function assertValidProps(props) {
-  if (!props) {
-    return;
-  }
-  // Note the use of `!=` which checks for null or undefined.
-  var hasChildren = props.children != null ? 1 : 0;
-  var hasContent = props.content != null ? 1 : 0;
-  var hasInnerHTML = props.dangerouslySetInnerHTML != null ? 1 : 0;
-  invariant(
-    hasChildren + hasContent + hasInnerHTML <= 1,
-    'Can only set one of `children`, `props.content`, or ' +
-    '`props.dangerouslySetInnerHTML`.'
-  );
-  invariant(
-    props.style == null || typeof props.style === 'object',
-    'The `style` prop expects a mapping from style properties to values, ' +
-    'not a string.'
-  );
-}
-
-/**
- * @constructor ReactNativeComponent
- * @extends ReactComponent
- * @extends ReactMultiChild
- */
-function ReactNativeComponent(tag, omitClose) {
-  this._tagOpen = '<' + tag + ' ';
-  this._tagClose = omitClose ? '' : '</' + tag + '>';
-  this.tagName = tag.toUpperCase();
-}
-
-ReactNativeComponent.Mixin = {
-
-  /**
-   * Generates root tag markup then recurses. This method has side effects and
-   * is not idempotent.
-   *
-   * @internal
-   * @param {string} rootID The root DOM ID for this node.
-   * @param {ReactReconcileTransaction} transaction
-   * @return {string} The computed markup.
-   */
-  mountComponent: function(rootID, transaction) {
-    ReactComponent.Mixin.mountComponent.call(this, rootID, transaction);
-    assertValidProps(this.props);
-    return (
-      this._createOpenTagMarkup() +
-      this._createContentMarkup(transaction) +
-      this._tagClose
-    );
-  },
-
-  /**
-   * Creates markup for the open tag and all attributes.
-   *
-   * This method has side effects because events get registered.
-   *
-   * Iterating over object properties is faster than iterating over arrays.
-   * @see http://jsperf.com/obj-vs-arr-iteration
-   *
-   * @private
-   * @return {string} Markup of opening tag.
-   */
-  _createOpenTagMarkup: function() {
-    var props = this.props;
-    var ret = this._tagOpen;
-
-    for (var propKey in props) {
-      if (!props.hasOwnProperty(propKey)) {
-        continue;
-      }
-      var propValue = props[propKey];
-      if (propValue == null) {
-        continue;
-      }
-      if (registrationNames[propKey]) {
-        putListener(this._rootNodeID, propKey, propValue);
-      } else {
-        if (propKey === STYLE) {
-          if (propValue) {
-            propValue = props.style = merge(props.style);
-          }
-          propValue = CSSPropertyOperations.createMarkupForStyles(propValue);
-        }
-        var markup =
-          DOMPropertyOperations.createMarkupForProperty(propKey, propValue);
-        if (markup) {
-          ret += ' ' + markup;
-        }
-      }
-    }
-
-    return ret + ' id="' + this._rootNodeID + '">';
-  },
-
-  /**
-   * Creates markup for the content between the tags.
-   *
-   * @private
-   * @param {ReactReconcileTransaction} transaction
-   * @return {string} Content markup.
-   */
-  _createContentMarkup: function(transaction) {
-    // Intentional use of != to avoid catching zero/false.
-    var innerHTML = this.props.dangerouslySetInnerHTML;
-    if (innerHTML != null) {
-      if (innerHTML.__html != null) {
-        return innerHTML.__html;
-      }
-    } else {
-      var contentToUse = this.props.content != null ? this.props.content :
-        CONTENT_TYPES[typeof this.props.children] ? this.props.children : null;
-      var childrenToUse = contentToUse != null ? null : this.props.children;
-      if (contentToUse != null) {
-        return escapeTextForBrowser(contentToUse);
-      } else if (childrenToUse != null) {
-        return this.mountMultiChild(
-          flattenChildren(childrenToUse),
-          transaction
-        );
-      }
-    }
-    return '';
-  },
-
-  /**
-   * Controls a native DOM component after it has already been allocated and
-   * attached to the DOM. Reconciles the root DOM node, then recurses.
-   *
-   * @internal
-   * @param {object} nextProps
-   * @param {ReactReconcileTransaction} transaction
-   */
-  receiveProps: function(nextProps, transaction) {
-    invariant(
-      this._rootNodeID,
-      'Trying to control a native dom element without a backing id'
-    );
-    assertValidProps(nextProps);
-    ReactComponent.Mixin.receiveProps.call(this, nextProps, transaction);
-    this._updateDOMProperties(nextProps);
-    this._updateDOMChildren(nextProps, transaction);
-    this.props = nextProps;
-  },
-
-  /**
-   * Reconciles the properties by detecting differences in property values and
-   * updating the DOM as necessary. This function is probably the single most
-   * critical path for performance optimization.
-   *
-   * TODO: Benchmark whether checking for changed values in memory actually
-   *       improves performance (especially statically positioned elements).
-   * TODO: Benchmark the effects of putting this at the top since 99% of props
-   *       do not change for a given reconciliation.
-   * TODO: Benchmark areas that can be improved with caching.
-   *
-   * @private
-   * @param {object} nextProps
-   */
-  _updateDOMProperties: function(nextProps) {
-    var lastProps = this.props;
-    for (var propKey in nextProps) {
-      var nextProp = nextProps[propKey];
-      var lastProp = lastProps[propKey];
-      if (!nextProps.hasOwnProperty(propKey) || nextProp === lastProp) {
-        continue;
-      }
-      if (propKey === STYLE) {
-        if (nextProp) {
-          nextProp = nextProps.style = merge(nextProp);
-        }
-        var styleUpdates;
-        for (var styleName in nextProp) {
-          if (!nextProp.hasOwnProperty(styleName)) {
-            continue;
-          }
-          if (!lastProp || lastProp[styleName] !== nextProp[styleName]) {
-            if (!styleUpdates) {
-              styleUpdates = {};
-            }
-            styleUpdates[styleName] = nextProp[styleName];
-          }
-        }
-        if (styleUpdates) {
-          ReactComponent.DOMIDOperations.updateStylesByID(
-            this._rootNodeID,
-            styleUpdates
-          );
-        }
-      } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
-        var lastHtml = lastProp && lastProp.__html;
-        var nextHtml = nextProp && nextProp.__html;
-        if (lastHtml !== nextHtml) {
-          ReactComponent.DOMIDOperations.updateInnerHTMLByID(
-            this._rootNodeID,
-            nextProp
-          );
-        }
-      } else if (propKey === CONTENT) {
-        ReactComponent.DOMIDOperations.updateTextContentByID(
-          this._rootNodeID,
-          '' + nextProp
-        );
-      } else if (registrationNames[propKey]) {
-        putListener(this._rootNodeID, propKey, nextProp);
-      } else {
-        ReactComponent.DOMIDOperations.updatePropertyByID(
-          this._rootNodeID,
-          propKey,
-          nextProp
-        );
-      }
-    }
-  },
-
-  /**
-   * Reconciles the children with the various properties that affect the
-   * children content.
-   *
-   * @param {object} nextProps
-   * @param {ReactReconcileTransaction} transaction
-   */
-  _updateDOMChildren: function(nextProps, transaction) {
-    var thisPropsContentType = typeof this.props.content;
-    var thisPropsContentEmpty =
-      this.props.content == null || thisPropsContentType === 'boolean';
-    var nextPropsContentType = typeof nextProps.content;
-    var nextPropsContentEmpty =
-      nextProps.content == null || nextPropsContentType === 'boolean';
-
-    var lastUsedContent = !thisPropsContentEmpty ? this.props.content :
-      CONTENT_TYPES[typeof this.props.children] ? this.props.children : null;
-
-    var contentToUse = !nextPropsContentEmpty ? nextProps.content :
-      CONTENT_TYPES[typeof nextProps.children] ? nextProps.children : null;
-
-    // Note the use of `!=` which checks for null or undefined.
-
-    var lastUsedChildren =
-      lastUsedContent != null ? null : this.props.children;
-    var childrenToUse = contentToUse != null ? null : nextProps.children;
-
-    if (contentToUse != null) {
-      var childrenRemoved = lastUsedChildren != null && childrenToUse == null;
-      if (childrenRemoved) {
-        this.updateMultiChild(null, transaction);
-      }
-      if (lastUsedContent !== contentToUse) {
-        ReactComponent.DOMIDOperations.updateTextContentByID(
-          this._rootNodeID,
-          '' + contentToUse
-        );
-      }
-    } else {
-      var contentRemoved = lastUsedContent != null && contentToUse == null;
-      if (contentRemoved) {
-        ReactComponent.DOMIDOperations.updateTextContentByID(
-          this._rootNodeID,
-          ''
-        );
-      }
-      this.updateMultiChild(flattenChildren(nextProps.children), transaction);
-    }
-  },
-
-  /**
-   * Destroys all event registrations for this instance. Does not remove from
-   * the DOM. That must be done by the parent.
-   *
-   * @internal
-   */
-  unmountComponent: function() {
-    ReactComponent.Mixin.unmountComponent.call(this);
-    this.unmountMultiChild();
-    ReactEvent.deleteAllListeners(this._rootNodeID);
-  }
-
-};
-
-mixInto(ReactNativeComponent, ReactComponent.Mixin);
-mixInto(ReactNativeComponent, ReactNativeComponent.Mixin);
-mixInto(ReactNativeComponent, ReactMultiChild.Mixin);
-
-module.exports = ReactNativeComponent;
diff --git a/React/ReactOnDOMReady.js b/React/ReactOnDOMReady.js
deleted file mode 100644
index a425ff03be..0000000000
--- a/React/ReactOnDOMReady.js
+++ /dev/null
@@ -1,95 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactOnDOMReady
- */
-
-"use strict";
-
-var PooledClass = require("./PooledClass");
-
-var mixInto = require("./mixInto");
-
-/**
- * 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 `ReactOnDOMReady.getPooled()`.
- *
- * @param {?array<function>} initialCollection
- * @class ReactOnDOMReady
- * @implements PooledClass
- * @internal
- */
-function ReactOnDOMReady(initialCollection) {
-  this._queue = initialCollection || null;
-}
-
-mixInto(ReactOnDOMReady, {
-
-  /**
-   * Enqueues a callback to be invoked when `notifyAll` is invoked. This is used
-   * to enqueue calls to `componentDidMount` and `componentDidUpdate`.
-   *
-   * @param {ReactComponent} component Component being rendered.
-   * @param {function(DOMElement)} callback Invoked when `notifyAll` is invoked.
-   * @internal
-   */
-  enqueue: function(component, callback) {
-    this._queue = this._queue || [];
-    this._queue.push({component: component, callback: callback});
-  },
-
-  /**
-   * 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 queue = this._queue;
-    if (queue) {
-      this._queue = null;
-      for (var i = 0, l = queue.length; i < l; i++) {
-        var component = queue[i].component;
-        var callback = queue[i].callback;
-        callback.call(component, component.getDOMNode());
-      }
-      queue.length = 0;
-    }
-  },
-
-  /**
-   * Resets the internal queue.
-   *
-   * @internal
-   */
-  reset: function() {
-    this._queue = null;
-  },
-
-  /**
-   * `PooledClass` looks for this.
-   */
-  destructor: function() {
-    this.reset();
-  }
-
-});
-
-PooledClass.addPoolingTo(ReactOnDOMReady);
-
-module.exports = ReactOnDOMReady;
diff --git a/React/ReactOwner.js b/React/ReactOwner.js
deleted file mode 100644
index 4710d36f63..0000000000
--- a/React/ReactOwner.js
+++ /dev/null
@@ -1,146 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactOwner
- */
-
-"use strict";
-
-var invariant = require("./invariant");
-
-/**
- * ReactOwners are capable of storing references to owned components.
- *
- * All components are capable of //being// referenced by owner components, but
- * only ReactOwner components are capable of //referencing// owned components.
- * The named reference is known as a "ref".
- *
- * Refs are available when mounted and updated during reconciliation.
- *
- *   var MyComponent = React.createClass({
- *     render: function() {
- *       return (
- *         <div onClick={this.handleClick}>
- *           <CustomComponent ref="custom" />
- *         </div>
- *       );
- *     },
- *     handleClick: React.autoBind(function() {
- *       this.refs.custom.handleClick();
- *     }),
- *     componentDidMount: function() {
- *       this.refs.custom.initialize();
- *     }
- *   });
- *
- * Refs should rarely be used. When refs are used, they should only be done to
- * control data that is not handled by React's data flow.
- *
- * @class ReactOwner
- */
-var ReactOwner = {
-
-  /**
-   * @param {?object} object
-   * @return {boolean} True if `object` is a valid owner.
-   * @final
-   */
-  isValidOwner: function(object) {
-    return !!(
-      object &&
-      typeof object.attachRef === 'function' &&
-      typeof object.detachRef === 'function'
-    );
-  },
-
-  /**
-   * Adds a component by ref to an owner component.
-   *
-   * @param {ReactComponent} component Component to reference.
-   * @param {string} ref Name by which to refer to the component.
-   * @param {ReactOwner} owner Component on which to record the ref.
-   * @final
-   * @internal
-   */
-  addComponentAsRefTo: function(component, ref, owner) {
-    invariant(
-      ReactOwner.isValidOwner(owner),
-      'addComponentAsRefTo(...): Only a ReactOwner can have refs.'
-    );
-    owner.attachRef(ref, component);
-  },
-
-  /**
-   * Removes a component by ref from an owner component.
-   *
-   * @param {ReactComponent} component Component to dereference.
-   * @param {string} ref Name of the ref to remove.
-   * @param {ReactOwner} owner Component on which the ref is recorded.
-   * @final
-   * @internal
-   */
-  removeComponentAsRefFrom: function(component, ref, owner) {
-    invariant(
-      ReactOwner.isValidOwner(owner),
-      'removeComponentAsRefFrom(...): Only a ReactOwner can have refs.'
-    );
-    // Check that `component` is still the current ref because we do not want to
-    // detach the ref if another component stole it.
-    if (owner.refs[ref] === component) {
-      owner.detachRef(ref);
-    }
-  },
-
-  /**
-   * A ReactComponent must mix this in to have refs.
-   *
-   * @lends {ReactOwner.prototype}
-   */
-  Mixin: {
-
-    /**
-     * Lazily allocates the refs object and stores `component` as `ref`.
-     *
-     * @param {string} ref Reference name.
-     * @param {component} component Component to store as `ref`.
-     * @final
-     * @private
-     */
-    attachRef: function(ref, component) {
-      invariant(
-        component.isOwnedBy(this),
-        'attachRef(%s, ...): Only a component\'s owner can store a ref to it.',
-        ref
-      );
-      var refs = this.refs || (this.refs = {});
-      refs[ref] = component;
-    },
-
-    /**
-     * Detaches a reference name.
-     *
-     * @param {string} ref Name to dereference.
-     * @final
-     * @private
-     */
-    detachRef: function(ref) {
-      delete this.refs[ref];
-    }
-
-  }
-
-};
-
-module.exports = ReactOwner;
diff --git a/React/ReactPropTransferer.js b/React/ReactPropTransferer.js
deleted file mode 100644
index fcf2cee3d9..0000000000
--- a/React/ReactPropTransferer.js
+++ /dev/null
@@ -1,114 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactPropTransferer
- */
-
-"use strict";
-
-var emptyFunction = require("./emptyFunction");
-var joinClasses = require("./joinClasses");
-var merge = require("./merge");
-
-/**
- * Creates a transfer strategy that will merge prop values using the supplied
- * `mergeStrategy`. If a prop was previously unset, this just sets it.
- *
- * @param {function} mergeStrategy
- * @return {function}
- */
-function createTransferStrategy(mergeStrategy) {
-  return function(props, key, value) {
-    if (!props.hasOwnProperty(key)) {
-      props[key] = value;
-    } else {
-      props[key] = mergeStrategy(props[key], value);
-    }
-  };
-}
-
-/**
- * Transfer strategies dictate how props are transferred by `transferPropsTo`.
- */
-var TransferStrategies = {
-  /**
-   * Never transfer the `ref` prop.
-   */
-  ref: emptyFunction,
-  /**
-   * Transfer the `className` prop by merging them.
-   */
-  className: createTransferStrategy(joinClasses),
-  /**
-   * Transfer the `style` prop (which is an object) by merging them.
-   */
-  style: createTransferStrategy(merge)
-};
-
-/**
- * ReactPropTransferer are capable of transferring props to another component
- * using a `transferPropsTo` method.
- *
- * @class ReactPropTransferer
- */
-var ReactPropTransferer = {
-
-  TransferStrategies: TransferStrategies,
-
-  /**
-   * @lends {ReactPropTransferer.prototype}
-   */
-  Mixin: {
-
-    /**
-     * Transfer props from this component to a target component.
-     *
-     * Props that do not have an explicit transfer strategy will be transferred
-     * only if the target component does not already have the prop set.
-     *
-     * This is usually used to pass down props to a returned root component.
-     *
-     * @param {ReactComponent} component Component receiving the properties.
-     * @return {ReactComponent} The supplied `component`.
-     * @final
-     * @protected
-     */
-    transferPropsTo: function(component) {
-      var props = {};
-      for (var thatKey in component.props) {
-        if (component.props.hasOwnProperty(thatKey)) {
-          props[thatKey] = component.props[thatKey];
-        }
-      }
-      for (var thisKey in this.props) {
-        if (!this.props.hasOwnProperty(thisKey)) {
-          continue;
-        }
-        var transferStrategy = TransferStrategies[thisKey];
-        if (transferStrategy) {
-          transferStrategy(props, thisKey, this.props[thisKey]);
-        } else if (!props.hasOwnProperty(thisKey)) {
-          props[thisKey] = this.props[thisKey];
-        }
-      }
-      component.props = props;
-      return component;
-    }
-
-  }
-
-};
-
-module.exports = ReactPropTransferer;
diff --git a/React/ReactProps.js b/React/ReactProps.js
deleted file mode 100644
index f7b55116f6..0000000000
--- a/React/ReactProps.js
+++ /dev/null
@@ -1,157 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactProps
- */
-
-"use strict";
-
-var createObjectFrom = require("./createObjectFrom");
-var invariant = require("./invariant");
-
-/**
- * Collection of methods that allow declaration and validation of props that are
- * supplied to React components. Example usage:
- *
- *   var Props = require('ReactProps');
- *   var MyArticle = React.createClass({
- *     props: {
- *       // An optional string prop named "description".
- *       description: Props.string,
- *
- *       // A required enum prop named "category".
- *       category: Props.oneOf(['News','Photos']).isRequired,
- *
- *       // A prop named "dialog" that requires an instance of Dialog.
- *       dialog: Props.instanceOf(Dialog).isRequired
- *     },
- *     render: function() { ... }
- *   });
- *
- * A more formal specification of how these methods are used:
- *
- *   type := array|bool|object|number|string|oneOf([...])|instanceOf(...)
- *   decl := ReactProps.{type}(.isRequired)?
- *
- * Each and every declaration produces a function with the same signature. This
- * allows the creation of custom validation functions. For example:
- *
- *   var Props = require('ReactProps');
- *   var MyLink = React.createClass({
- *     props: {
- *       // An optional string or URI prop named "href".
- *       href: function(props, propName, componentName) {
- *         var propValue = props[propName];
- *         invariant(
- *           propValue == null ||
- *           typeof propValue === string ||
- *           propValue instanceof URI,
- *           'Invalid `%s` supplied to `%s`, expected string or URI.',
- *           propName,
- *           componentName
- *         );
- *       }
- *     },
- *     render: function() { ... }
- *   });
- *
- * @internal
- */
-var Props = {
-
-  array: createPrimitiveTypeChecker('array'),
-  bool: createPrimitiveTypeChecker('boolean'),
-  number: createPrimitiveTypeChecker('number'),
-  object: createPrimitiveTypeChecker('object'),
-  string: createPrimitiveTypeChecker('string'),
-
-  oneOf: createEnumTypeChecker,
-
-  instanceOf: createInstanceTypeChecker
-
-};
-
-var ANONYMOUS = '<<anonymous>>';
-
-function createPrimitiveTypeChecker(expectedType) {
-  function validatePrimitiveType(propValue, propName, componentName) {
-    var propType = typeof propValue;
-    if (propType === 'object' && Array.isArray(propValue)) {
-      propType = 'array';
-    }
-    invariant(
-      propType === expectedType,
-      'Invalid prop `%s` of type `%s` supplied to `%s`, expected `%s`.',
-      propName,
-      propType,
-      componentName,
-      expectedType
-    );
-  }
-  return createChainableTypeChecker(validatePrimitiveType);
-}
-
-function createEnumTypeChecker(expectedValues) {
-  var expectedEnum = createObjectFrom(expectedValues);
-  function validateEnumType(propValue, propName, componentName) {
-    invariant(
-      expectedEnum[propValue],
-      'Invalid prop `%s` supplied to `%s`, expected one of %s.',
-      propName,
-      componentName,
-      JSON.stringify(Object.keys(expectedEnum))
-    );
-  }
-  return createChainableTypeChecker(validateEnumType);
-}
-
-function createInstanceTypeChecker(expectedClass) {
-  function validateInstanceType(propValue, propName, componentName) {
-    invariant(
-      propValue instanceof expectedClass,
-      'Invalid prop `%s` supplied to `%s`, expected instance of `%s`.',
-      propName,
-      componentName,
-      expectedClass.name || ANONYMOUS
-    );
-  }
-  return createChainableTypeChecker(validateInstanceType);
-}
-
-function createChainableTypeChecker(validate) {
-  function createTypeChecker(isRequired) {
-    function checkType(props, propName, componentName) {
-      var propValue = props[propName];
-      if (propValue != null) {
-        // Only validate if there is a value to check.
-        validate(propValue, propName, componentName || ANONYMOUS);
-      } else {
-        invariant(
-          !isRequired,
-          'Required prop `%s` was not specified in `%s`.',
-          propName,
-          componentName || ANONYMOUS
-        );
-      }
-    }
-    if (!isRequired) {
-      checkType.isRequired = createTypeChecker(true);
-    }
-    return checkType;
-  }
-  return createTypeChecker(false);
-}
-
-module.exports = Props;
diff --git a/React/ReactReconcileTransaction.js b/React/ReactReconcileTransaction.js
deleted file mode 100644
index d992720936..0000000000
--- a/React/ReactReconcileTransaction.js
+++ /dev/null
@@ -1,161 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactReconcileTransaction
- * @typechecks
- */
-
-"use strict";
-
-var ExecutionEnvironment = require("./ExecutionEnvironment");
-var PooledClass = require("./PooledClass");
-var ReactEvent = require("./ReactEvent");
-var ReactInputSelection = require("./ReactInputSelection");
-var ReactOnDOMReady = require("./ReactOnDOMReady");
-var Transaction = require("./Transaction");
-
-var mixInto = require("./mixInto");
-
-/**
- * Ensures that, when possible, the selection range (currently selected text
- * input) is not disturbed by performing the transaction.
- */
-var SELECTION_RESTORATION = {
-  /**
-   * @return {Selection} Selection information.
-   */
-  initialize: ReactInputSelection.getSelectionInformation,
-  /**
-   * @param {Selection} sel Selection information returned from `initialize`.
-   */
-  close: ReactInputSelection.restoreSelection
-};
-
-/**
- * Suppresses events (blur/focus) that could be inadvertently dispatched due to
- * high level DOM manipulations (like temporarily removing a text input from the
- * DOM).
- */
-var EVENT_SUPPRESSION = {
-  /**
-   * @return {boolean} The enabled status of `ReactEvent` before the
-   * reconciliation.
-   */
-  initialize: function() {
-    var currentlyEnabled = ReactEvent.isEnabled();
-    ReactEvent.setEnabled(false);
-    return currentlyEnabled;
-  },
-
-  /**
-   * @param {boolean} previouslyEnabled The enabled status of `ReactEvent`
-   *   before the reconciliation occured. `close` restores the previous value.
-   */
-  close: function(previouslyEnabled) {
-    ReactEvent.setEnabled(previouslyEnabled);
-  }
-};
-
-/**
- * Provides a `ReactOnDOMReady` queue for collecting `onDOMReady` callbacks
- * during the performing of the transaction.
- */
-var ON_DOM_READY_QUEUEING = {
-  /**
-   * Initializes the internal `onDOMReady` queue.
-   */
-  initialize: function() {
-    this.reactOnDOMReady.reset();
-  },
-
-  /**
-   * After DOM is flushed, invoke all registered `onDOMReady` callbacks.
-   */
-  close: function() {
-    this.reactOnDOMReady.notifyAll();
-  }
-};
-
-/**
- * Executed within the scope of the `Transaction` instance. Consider these as
- * being member methods, but with an implied ordering while being isolated from
- * each other.
- */
-var TRANSACTION_WRAPPERS = [
-  SELECTION_RESTORATION,
-  EVENT_SUPPRESSION,
-  ON_DOM_READY_QUEUEING
-];
-
-/**
- * Currently:
- * - The order that these are listed in the transaction is critical:
- * - Suppresses events.
- * - Restores selection range.
- *
- * Future:
- * - Restore document/overflow scroll positions that were unintentionally
- *   modified via DOM insertions above the top viewport boundary.
- * - Implement/integrate with customized constraint based layout system and keep
- *   track of which dimensions must be remeasured.
- *
- * @class ReactReconcileTransaction
- */
-function ReactReconcileTransaction() {
-  this.reinitializeTransaction();
-  this.reactOnDOMReady = ReactOnDOMReady.getPooled(null);
-}
-
-var Mixin = {
-  /**
-   * @see Transaction
-   * @abstract
-   * @final
-   * @return {array<object>} List of operation wrap proceedures.
-   *   TODO: convert to array<TransactionWrapper>
-   */
-  getTransactionWrappers: function() {
-    if (ExecutionEnvironment.canUseDOM) {
-      return TRANSACTION_WRAPPERS;
-    } else {
-      return [];
-    }
-  },
-
-  /**
-   * @return {object} The queue to collect `onDOMReady` callbacks with.
-   *   TODO: convert to ReactOnDOMReady
-   */
-  getReactOnDOMReady: function() {
-    return this.reactOnDOMReady;
-  },
-
-  /**
-   * `PooledClass` looks for this, and will invoke this before allowing this
-   * instance to be resused.
-   */
-  destructor: function() {
-    ReactOnDOMReady.release(this.reactOnDOMReady);
-    this.reactOnDOMReady = null;
-  }
-};
-
-
-mixInto(ReactReconcileTransaction, Transaction.Mixin);
-mixInto(ReactReconcileTransaction, Mixin);
-
-PooledClass.addPoolingTo(ReactReconcileTransaction);
-
-module.exports = ReactReconcileTransaction;
diff --git a/React/ReactStateSetters.js b/React/ReactStateSetters.js
deleted file mode 100644
index 46d38a3377..0000000000
--- a/React/ReactStateSetters.js
+++ /dev/null
@@ -1,111 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactStateSetters
- */
-
-"use strict";
-
-var ReactStateSetters = {
-  /**
-   * Returns a function that calls the provided function, and uses the result
-   * of that to set the component's state.
-   *
-   * @param {ReactCompositeComponent} component
-   * @param {function} funcReturningState Returned callback uses this to
-   *                                      determine how to update state.
-   * @return {function} callback that when invoked uses funcReturningState to
-   *                    determined the object literal to setState.
-   */
-  createStateSetter: function(component, funcReturningState) {
-    return function(a, b, c, d, e, f) {
-      var partialState = funcReturningState.call(component, a, b, c, d, e, f);
-      if (partialState) {
-        component.setState(partialState);
-      }
-    };
-  },
-
-  /**
-   * Returns a single-argument callback that can be used to update a single
-   * key in the component's state.
-   *
-   * Note: this is memoized function, which makes it inexpensive to call.
-   *
-   * @param {ReactCompositeComponent} component
-   * @param {string} key The key in the state that you should update.
-   * @return {function} callback of 1 argument which calls setState() with
-   *                    the provided keyName and callback argument.
-   */
-  createStateKeySetter: function(component, key) {
-    // Memoize the setters.
-    var cache = component.__keySetters || (component.__keySetters = {});
-    return cache[key] || (cache[key] = createStateKeySetter(component, key));
-  }
-};
-
-function createStateKeySetter(component, key) {
-  // Partial state is allocated outside of the function closure so it can be
-  // reused with every call, avoiding memory allocation when this function
-  // is called.
-  var partialState = {};
-  return function stateKeySetter(value) {
-    partialState[key] = value;
-    component.setState(partialState);
-  };
-}
-
-ReactStateSetters.Mixin = {
-  /**
-   * Returns a function that calls the provided function, and uses the result
-   * of that to set the component's state.
-   *
-   * For example, these statements are equivalent:
-   *
-   *   this.setState({x: 1});
-   *   this.createStateSetter(function(xValue) {
-   *     return {x: xValue};
-   *   })(1);
-   *
-   * @param {function} funcReturningState Returned callback uses this to
-   *                                      determine how to update state.
-   * @return {function} callback that when invoked uses funcReturningState to
-   *                    determined the object literal to setState.
-   */
-  createStateSetter: function(funcReturningState) {
-    return ReactStateSetters.createStateSetter(this, funcReturningState);
-  },
-
-  /**
-   * Returns a single-argument callback that can be used to update a single
-   * key in the component's state.
-   *
-   * For example, these statements are equivalent:
-   *
-   *   this.setState({x: 1});
-   *   this.createStateKeySetter('x')(1);
-   *
-   * Note: this is memoized function, which makes it inexpensive to call.
-   *
-   * @param {string} key The key in the state that you should update.
-   * @return {function} callback of 1 argument which calls setState() with
-   *                    the provided keyName and callback argument.
-   */
-  createStateKeySetter: function(key) {
-    return ReactStateSetters.createStateKeySetter(this, key);
-  }
-};
-
-module.exports = ReactStateSetters;
diff --git a/React/ReactTestUtils.js b/React/ReactTestUtils.js
deleted file mode 100644
index 3db1354560..0000000000
--- a/React/ReactTestUtils.js
+++ /dev/null
@@ -1,284 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactTestUtils
- */
-
-var EventConstants = require("./EventConstants");
-var React = require("./React");
-var ReactComponent = require("./ReactComponent");
-var ReactEvent = require("./ReactEvent");
-var ReactTextComponent = require("./ReactTextComponent");
-
-var ge = require("./ge");
-var mergeInto = require("./mergeInto");
-
-var topLevelTypes = EventConstants.topLevelTypes;
-
-function Event(suffix) {}
-
-/**
- * @class ReactTestUtils
- */
-
-/**
- * Todo: Support the entire DOM.scry query syntax. For now, these simple
- * utilities will suffice for testing purposes.
- * @lends ReactTestUtils
- */
-var ReactTestUtils = {
-  renderIntoDocument: function(instance) {
-    var div = document.createElement('div');
-    document.documentElement.appendChild(div);
-    return React.renderComponent(instance, div);
-  },
-
-  isDOMComponent: function(inst) {
-    return !!(inst &&
-              ReactComponent.isValidComponent(inst) &&
-              !!inst.tagName);
-  },
-
-  isCompositeComponent: function(inst) {
-    return !!(
-      inst &&
-      ReactComponent.isValidComponent(inst) &&
-      typeof inst.render === 'function' &&
-      typeof inst.setState === 'function' &&
-      typeof inst.updateComponent === 'function'
-    );
-  },
-
-  isCompositeComponentWithType: function(inst, type) {
-    return !!(ReactTestUtils.isCompositeComponent(inst) &&
-             (inst.constructor === type.componentConstructor ||
-              inst.constructor === type));
-  },
-
-  isTextComponent: function(inst) {
-    return inst instanceof ReactTextComponent;
-  },
-
-  findAllInRenderedTree: function(inst, test) {
-    if (!inst) {
-      return [];
-    }
-    var ret = test(inst) ? [inst] : [];
-    if (ReactTestUtils.isDOMComponent(inst)) {
-      var renderedChildren = inst._renderedChildren;
-      var key;
-      for (key in renderedChildren) {
-        if (!renderedChildren.hasOwnProperty(key)) {
-          continue;
-        }
-        ret = ret.concat(
-          ReactTestUtils.findAllInRenderedTree(renderedChildren[key], test)
-        );
-      }
-    } else if (ReactTestUtils.isCompositeComponent(inst)) {
-      ret = ret.concat(
-        ReactTestUtils.findAllInRenderedTree(inst._renderedComponent, test)
-      );
-    }
-    return ret;
-  },
-
-  /**
-   * Finds all instance of components in the rendered tree that are DOM
-   * components with the class name matching `className`.
-   * @return an array of all the matches.
-   */
-  scryRenderedDOMComponentsWithClass: function(root, className) {
-    return ReactTestUtils.findAllInRenderedTree(root, function(inst) {
-      var instClassName = inst.props.className;
-      return ReactTestUtils.isDOMComponent(inst) && (
-        instClassName &&
-        (' ' + instClassName + ' ').indexOf(' ' + className + ' ') !== -1
-      );
-    });
-  },
-
-  /**
-   * Like scryRenderedDOMComponentsWithClass but expects there to be one result,
-   * and returns that one result, or throws exception if there is any other
-   * number of matches besides one.
-   * @return {!ReactNativeComponent} The one match.
-   */
-  findRenderedDOMComponentWithClass: function(root, className) {
-    var all =
-      ReactTestUtils.scryRenderedDOMComponentsWithClass(root, className);
-    if (all.length !== 1) {
-      throw new Error('Did not find exactly one match for class:' + className);
-    }
-    return all[0];
-  },
-
-
-  /**
-   * Finds all instance of components in the rendered tree that are DOM
-   * components with the tag name matching `tagName`.
-   * @return an array of all the matches.
-   */
-  scryRenderedDOMComponentsWithTag: function(root, tagName) {
-    return ReactTestUtils.findAllInRenderedTree(root, function(inst) {
-      return ReactTestUtils.isDOMComponent(inst) &&
-            inst.tagName === tagName.toUpperCase();
-    });
-  },
-
-  /**
-   * Like scryRenderedDOMComponentsWithTag but expects there to be one result,
-   * and returns that one result, or throws exception if there is any other
-   * number of matches besides one.
-   * @return {!ReactNativeComponent} The one match.
-   */
-  findRenderedDOMComponentWithTag: function(root, tagName) {
-    var all = ReactTestUtils.scryRenderedDOMComponentsWithTag(root, tagName);
-    if (all.length !== 1) {
-      throw new Error('Did not find exactly one match for tag:' + tagName);
-    }
-    return all[0];
-  },
-
-
-  /**
-   * Finds all instances of components with type equal to `componentType`.
-   * @return an array of all the matches.
-   */
-  scryRenderedComponentsWithType: function(root, componentType) {
-    return ReactTestUtils.findAllInRenderedTree(root, function(inst) {
-      return ReactTestUtils.isCompositeComponentWithType(inst, componentType);
-    });
-  },
-
-  /**
-   * Same as `scryRenderedComponentsWithType` but expects there to be one result
-   * and returns that one result, or throws exception if there is any other
-   * number of matches besides one.
-   * @return {!ReactComponent} The one match.
-   */
-  findRenderedComponentWithType: function(root, componentType) {
-    var all = ReactTestUtils.scryRenderedComponentsWithType(
-      root,
-      componentType
-    );
-    if (all.length !== 1) {
-      throw new Error(
-        'Did not find exactly one match for componentType:' + componentType
-      );
-    }
-    return all[0];
-  },
-
-  /**
-   * Simulates a top level event being dispatched from a raw event that occured
-   * on and `Element` node.
-   * @param topLevelType {Object} A type from `EventConstants.topLevelTypes`
-   * @param {!Element} node The dom to simulate an event occurring on.
-   * @param {?Event} fakeNativeEvent Fake native event to pass to ReactEvent.
-   */
-  simulateEventOnNode: function(topLevelType, node, fakeNativeEvent) {
-    var virtualHandler =
-      ReactEvent.TopLevelCallbackCreator.createTopLevelCallback(topLevelType);
-    fakeNativeEvent.target = node;
-    virtualHandler(fakeNativeEvent);
-  },
-
-  /**
-   * Simulates a top level event being dispatched from a raw event that occured
-   * on the `ReactNativeComponent` `comp`.
-   * @param topLevelType {Object} A type from `EventConstants.topLevelTypes`.
-   * @param comp {!ReactNativeComponent}
-   * @param {?Event} fakeNativeEvent Fake native event to pass to ReactEvent.
-   */
-  simulateEventOnDOMComponent: function(topLevelType, comp, fakeNativeEvent) {
-    var reactRootID = comp._rootNodeID || comp._rootDomId;
-    if (!reactRootID) {
-      throw new Error('Simulating event on non-rendered component');
-    }
-    var virtualHandler =
-      ReactEvent.TopLevelCallbackCreator.createTopLevelCallback(topLevelType);
-    var node = ge(reactRootID);
-    fakeNativeEvent.target = node;
-    /* jsdom is returning nodes without id's - fixing that issue here. */
-    node.id = reactRootID;
-    virtualHandler(fakeNativeEvent);
-  },
-
-  nativeTouchData: function(x, y) {
-    return {
-      touches: [
-        {pageX: x, pageY: y}
-      ]
-    };
-  },
-
-  Simulate: null    // Will populate
-};
-
-/**
- * Exports:
- *
- * - `ReactTestUtils.Simulate.click(Element/ReactNativeComponent)`
- * - `ReactTestUtils.Simulate.mouseMove(Element/ReactNativeComponent)`
- * - `ReactTestUtils.Simulate.mouseIn/ReactNativeComponent)`
- * - `ReactTestUtils.Simulate.mouseOut(Element/ReactNativeComponent)`
- * - ... (All keys from `EventConstants.topLevelTypes`)
- *
- * Note: Top level event types are a subset of the entire set of handler types
- * (which include a broader set of "synthetic" events). For example, onDragDone
- * is a synthetic event. You certainly may write test cases for these event
- * types, but it doesn't make sense to simulate them at this low of a level. In
- * this case, the way you test an `onDragDone` event is by simulating a series
- * of `mouseMove`/ `mouseDown`/`mouseUp` events - Then, a synthetic event of
- * type `onDragDone` will be constructed and dispached through your system
- * automatically.
- */
-
-function makeSimulator(eventType) {
-  return function(domComponentOrNode, nativeEventData) {
-    var fakeNativeEvent = new Event(eventType);
-    mergeInto(fakeNativeEvent, nativeEventData);
-    if (ReactTestUtils.isDOMComponent(domComponentOrNode)) {
-      ReactTestUtils.simulateEventOnDOMComponent(
-        eventType,
-        domComponentOrNode,
-        fakeNativeEvent
-      );
-    } else if (!!domComponentOrNode.tagName) {
-      // Will allow on actual dom nodes.
-      ReactTestUtils.simulateEventOnNode(
-        eventType,
-        domComponentOrNode,
-        fakeNativeEvent
-      );
-    }
-  };
-}
-
-ReactTestUtils.Simulate = {};
-var eventType;
-for (eventType in topLevelTypes) {
-  // Event type is stored as 'topClick' - we transform that to 'click'
-  var convenienceName = eventType.indexOf('top') === 0 ?
-    eventType.charAt(3).toLowerCase() + eventType.substr(4) : eventType;
-  /**
-   * @param {!Element || ReactNativeComponent} domComponentOrNode
-   * @param {?Event} nativeEventData Fake native event to pass to ReactEvent.
-   */
-  ReactTestUtils.Simulate[convenienceName] = makeSimulator(eventType);
-}
-
-module.exports = ReactTestUtils;
diff --git a/React/ReactTextComponent.js b/React/ReactTextComponent.js
deleted file mode 100644
index a28dfdbdf8..0000000000
--- a/React/ReactTextComponent.js
+++ /dev/null
@@ -1,85 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactTextComponent
- * @typechecks
- */
-
-"use strict";
-
-var ReactComponent = require("./ReactComponent");
-
-var escapeTextForBrowser = require("./escapeTextForBrowser");
-var mixInto = require("./mixInto");
-
-/**
- * Text nodes violate a couple assumptions that React makes about components:
- *
- *  - When mounting text into the DOM, adjacent text nodes are merged.
- *  - Text nodes cannot be assigned a React root ID.
- *
- * This component is used to wrap strings in elements so that they can undergo
- * the same reconciliation that is applied to elements.
- *
- * TODO: Investigate representing React components in the DOM with text nodes.
- *
- * @class ReactTextComponent
- * @extends ReactComponent
- * @internal
- */
-var ReactTextComponent = function(initialText) {
-  this.construct({text: initialText});
-};
-
-mixInto(ReactTextComponent, ReactComponent.Mixin);
-mixInto(ReactTextComponent, {
-
-  /**
-   * Creates the markup for this text node. This node is not intended to have
-   * any features besides containing text content.
-   *
-   * @param {string} rootID DOM ID of the root node.
-   * @return {string} Markup for this text node.
-   * @internal
-   */
-  mountComponent: function(rootID) {
-    ReactComponent.Mixin.mountComponent.call(this, rootID);
-    return (
-      '<span id="' + rootID + '">' +
-        escapeTextForBrowser(this.props.text) +
-      '</span>'
-    );
-  },
-
-  /**
-   * Updates this component by updating the text content.
-   *
-   * @param {object} nextProps Contains the next text content.
-   * @param {ReactReconcileTransaction} transaction
-   * @internal
-   */
-  receiveProps: function(nextProps, transaction) {
-    if (nextProps.text !== this.props.text) {
-      this.props.text = nextProps.text;
-      ReactComponent.DOMIDOperations.updateTextContentByID(
-        this._rootNodeID,
-        nextProps.text
-      );
-    }
-  }
-
-});
-
-module.exports = ReactTextComponent;
diff --git a/React/ResponderEventPlugin.js b/React/ResponderEventPlugin.js
deleted file mode 100644
index addc439493..0000000000
--- a/React/ResponderEventPlugin.js
+++ /dev/null
@@ -1,312 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ResponderEventPlugin
- */
-
-"use strict";
-
-var AbstractEvent = require("./AbstractEvent");
-var EventConstants = require("./EventConstants");
-var EventPluginUtils = require("./EventPluginUtils");
-var EventPropagators = require("./EventPropagators");
-
-var accumulate = require("./accumulate");
-var keyOf = require("./keyOf");
-
-var isStartish = EventPluginUtils.isStartish;
-var isMoveish = EventPluginUtils.isMoveish;
-var isEndish = EventPluginUtils.isEndish;
-var executeDirectDispatch = EventPluginUtils.executeDirectDispatch;
-var hasDispatches = EventPluginUtils.hasDispatches;
-var executeDispatchesInOrderStopAtTrue =
-  EventPluginUtils.executeDispatchesInOrderStopAtTrue;
-
-/**
- * ID of element that should respond to touch/move types of interactions, as
- * indicated explicitly by relevant callbacks.
- */
-var responderID = null;
-var isPressing = false;
-
-var getResponderID = function() {
-  return responderID;
-};
-
-var abstractEventTypes = {
-  /**
-   * On a `touchStart`/`mouseDown`, is it desired that this element become the
-   * responder?
-   */
-  startShouldSetResponder: {
-    phasedRegistrationNames: {
-      bubbled: keyOf({onStartShouldSetResponder: null}),
-      captured: keyOf({onStartShouldSetResponderCapture: null})
-    }
-  },
-
-  /**
-   * On a `scroll`, is it desired that this element become the responder? This
-   * is usually not needed, but should be used to retroactively infer that a
-   * `touchStart` had occured during momentum scroll. During a momentum scroll,
-   * a touch start will be immediately followed by a scroll event if the view is
-   * currently scrolling.
-   */
-  scrollShouldSetResponder: {
-    phasedRegistrationNames: {
-      bubbled: keyOf({onScrollShouldSetResponder: null}),
-      captured: keyOf({onScrollShouldSetResponderCapture: null})
-    }
-  },
-
-  /**
-   * On a `touchMove`/`mouseMove`, is it desired that this element become the
-   * responder?
-   */
-  moveShouldSetResponder: {
-    phasedRegistrationNames: {
-      bubbled: keyOf({onMoveShouldSetResponder: null}),
-      captured: keyOf({onMoveShouldSetResponderCapture: null})
-    }
-  },
-
-  /**
-   * Direct responder events dispatched directly to responder. Do not bubble.
-   */
-  responderMove: {registrationName: keyOf({onResponderMove: null})},
-  responderRelease: {registrationName: keyOf({onResponderRelease: null})},
-  responderTerminationRequest: {
-    registrationName: keyOf({onResponderTerminationRequest: null})
-  },
-  responderGrant: {registrationName: keyOf({onResponderGrant: null})},
-  responderReject: {registrationName: keyOf({onResponderReject: null})},
-  responderTerminate: {registrationName: keyOf({onResponderTerminate: null})}
-};
-
-/**
- * Performs negotiation between any existing/current responder, checks to see if
- * any new entity is interested in becoming responder, performs that handshake
- * and returns any events that must be emitted to notify the relevant parties.
- *
- * A note about event ordering in the `EventPluginHub`.
- *
- * Suppose plugins are injected in the following order:
- *
- * `[R, S, C]`
- *
- * To help illustrate the example, assume `S` is `SimpleEventPlugin` (for
- * `onClick` etc) and `R` is `ResponderEventPlugin`.
- *
- * "Deferred-Dispatched Events":
- *
- * - The current event plugin system will traverse the list of injected plugins,
- *   in order, and extract events by collecting the plugin's return value of
- *   `extractAbstractEvents()`.
- * - These events that are returned from `extractAbstractEvents` are "deferred
- *   dispatched events".
- * - When returned from `extractAbstractEvents`, deferred dispatched events
- *   contain an "accumulation" of deferred dispatches.
- * -- These deferred dispatches are accumulated/collected before they are
- *  returned, but processed at a later time by the `EventPluginHub` (hence the
- *  name deferred).
- *
- * In the process of returning their deferred dispatched events, event plugins
- * themselves can dispatch events on-demand without returning them from
- * `extractAbstractEvents`. Plugins might want to do this, so that they can use
- * event dispatching as a tool that helps them decide which events should be
- * extracted in the first place.
- *
- * "On-Demand-Dispatched Events":
- *
- * - On-demand dispatched are not returned from `extractAbstractEvents`.
- * - On-demand dispatched events are dispatched during the process of returning
- *   the deferred-dispatched events.
- * - They should not have side effects.
- * - They should be avoided, and/or eventually be replaced with another
- *   abstraction that allows event plugins to perform multiple "rounds" of event
- *   extraction.
- *
- * Therefore, the sequence of event dispatches becomes:
- *
- * - `R`s on-demand events (if any)   (dispatched by `R` on-demand)
- * - `S`s on-demand events (if any)   (dispatched by `S` on-demand)
- * - `C`s on-demand events (if any)   (dispatched by `C` on-demand)
- * - `R`s extracted events (if any)   (dispatched by `EventPluginHub`)
- * - `S`s extracted events (if any)   (dispatched by `EventPluginHub`)
- * - `C`s extracted events (if any)   (dispatched by `EventPluginHub`)
- *
- * In the case of `ResponderEventPlugin`: If the `startShouldSetResponder`
- * on-demand dispatch returns `true` (and some other details are satisfied) the
- * `onResponderGrant` deferred dispatched event is returned from
- * `extractAbstractEvents`. The sequence of dispatch executions in this case
- * will appear as follows:
- *
- * - `startShouldSetResponder` (`ResponderEventPlugin` dispatches on-demand)
- * - `touchStartCapture`       (`EventPluginHub` dispatches as usual)
- * - `touchStart`              (`EventPluginHub` dispatches as usual)
- * - `responderGrant/Reject`   (`EventPluginHub` dispatches as usual)
- *
- * @returns {Accumulation<AbstractEvent>}
- */
-
-/**
- * @param {TopLevelTypes} topLevelType Top level event type being examined.
- * @param {DOMEvent} nativeEvent Native DOM event.
- * @param {string} renderedTargetID ID of deepest React rendered element.
- *
- * @return {Accumulation<AbstractEvent>} Extracted events.
- */
-var setResponderAndExtractTransfer =
-  function(topLevelType, nativeEvent, renderedTargetID) {
-    var type;
-    var shouldSetEventType =
-      isStartish(topLevelType) ? abstractEventTypes.startShouldSetResponder :
-      isMoveish(topLevelType) ? abstractEventTypes.moveShouldSetResponder :
-      abstractEventTypes.scrollShouldSetResponder;
-
-    var bubbleShouldSetFrom = responderID || renderedTargetID;
-    var shouldSetEvent = AbstractEvent.getPooled(
-      shouldSetEventType,
-      bubbleShouldSetFrom,
-      topLevelType,
-      nativeEvent,
-      AbstractEvent.normalizePointerData(nativeEvent)
-    );
-    EventPropagators.accumulateTwoPhaseDispatches(shouldSetEvent);
-    var wantsResponderID = executeDispatchesInOrderStopAtTrue(shouldSetEvent);
-    AbstractEvent.release(shouldSetEvent);
-
-    if (!wantsResponderID || wantsResponderID === responderID) {
-      return null;
-    }
-    var extracted;
-    var grantEvent = AbstractEvent.getPooled(
-      abstractEventTypes.responderGrant,
-      wantsResponderID,
-      topLevelType,
-      nativeEvent
-    );
-
-    EventPropagators.accumulateDirectDispatches(grantEvent);
-    if (responderID) {
-      type = abstractEventTypes.responderTerminationRequest;
-      var terminationRequestEvent = AbstractEvent.getPooled(type, responderID);
-      EventPropagators.accumulateDirectDispatches(terminationRequestEvent);
-      var shouldSwitch = !hasDispatches(terminationRequestEvent) ||
-        executeDirectDispatch(terminationRequestEvent);
-      AbstractEvent.release(terminationRequestEvent);
-      if (shouldSwitch) {
-        var terminateType = abstractEventTypes.responderTerminate;
-        var terminateEvent = AbstractEvent.getPooled(
-          terminateType,
-          responderID,
-          topLevelType,
-          nativeEvent
-        );
-        EventPropagators.accumulateDirectDispatches(terminateEvent);
-        extracted = accumulate(extracted, [grantEvent, terminateEvent]);
-        responderID = wantsResponderID;
-      } else {
-        var rejectEvent = AbstractEvent.getPooled(
-          abstractEventTypes.responderReject,
-          wantsResponderID,
-          topLevelType,
-          nativeEvent
-        );
-        EventPropagators.accumulateDirectDispatches(rejectEvent);
-        extracted = accumulate(extracted, rejectEvent);
-      }
-    } else {
-      extracted = accumulate(extracted, grantEvent);
-      responderID = wantsResponderID;
-    }
-    return extracted;
-  };
-
-
-/**
- * A transfer is a negotiation between a currently set responder and the next
- * element to claim responder status. Any start event could trigger a transfer
- * of responderID. Any move event could trigger a transfer, so long as there is
- * currently a responder set (in other words as long as the user is pressing
- * down).
- *
- * @param {EventConstants.topLevelTypes} topLevelType
- * @return {boolean} Whether or not a transfer of responder could possibly
- * occur.
- */
-function canTriggerTransfer(topLevelType) {
-  return topLevelType === EventConstants.topLevelTypes.topScroll ||
-         isStartish(topLevelType) ||
-         (isPressing && isMoveish(topLevelType));
-}
-
-var extractAbstractEvents =
-  function(topLevelType, nativeEvent, renderedTargetID, renderedTarget) {
-    var extracted;
-    // Must have missed an end event - reset the state here.
-    if (responderID && isStartish(topLevelType)) {
-      responderID = null;
-    }
-    if (isStartish(topLevelType)) {
-      isPressing = true;
-    } else if (isEndish(topLevelType)) {
-      isPressing = false;
-    }
-    if (canTriggerTransfer(topLevelType)) {
-      var transfer = setResponderAndExtractTransfer(
-        topLevelType,
-        nativeEvent,
-        renderedTargetID,
-        renderedTarget
-      );
-      if (transfer) {
-        extracted = accumulate(extracted, transfer);
-      }
-    }
-    // Now that we know the responder is set correctly, we can dispatch
-    // responder type events (directly to the responder).
-    var type = isMoveish(topLevelType) ? abstractEventTypes.responderMove :
-      isEndish(topLevelType) ? abstractEventTypes.responderRelease :
-      isStartish(topLevelType) ? abstractEventTypes.responderStart : null;
-    if (type) {
-      var data = AbstractEvent.normalizePointerData(nativeEvent);
-      var gesture = AbstractEvent.getPooled(
-        type,
-        responderID,
-        topLevelType,
-        nativeEvent,
-        data
-      );
-      EventPropagators.accumulateDirectDispatches(gesture);
-      extracted = accumulate(extracted, gesture);
-    }
-    if (type === abstractEventTypes.responderRelease) {
-      responderID = null;
-    }
-    return extracted;
-  };
-
-/**
- * Event plugin for formalizing the negotiation between claiming locks on
- * receiving touches.
- */
-var ResponderEventPlugin = {
-  abstractEventTypes: abstractEventTypes,
-  extractAbstractEvents: extractAbstractEvents,
-  getResponderID: getResponderID
-};
-
-module.exports = ResponderEventPlugin;
diff --git a/React/SimpleEventPlugin.js b/React/SimpleEventPlugin.js
deleted file mode 100644
index 88a483c2d5..0000000000
--- a/React/SimpleEventPlugin.js
+++ /dev/null
@@ -1,232 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule SimpleEventPlugin
- */
-
-"use strict";
-
-var AbstractEvent = require("./AbstractEvent");
-var EventConstants = require("./EventConstants");
-var EventPropagators = require("./EventPropagators");
-
-var keyOf = require("./keyOf");
-
-var topLevelTypes = EventConstants.topLevelTypes;
-
-var SimpleEventPlugin = {
-  abstractEventTypes: {
-    // Note: We do not allow listening to mouseOver events. Instead, use the
-    // onMouseEnter/onMouseLeave created by `EnterLeaveEventPlugin`.
-    mouseDown: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onMouseDown: true}),
-        captured: keyOf({onMouseDownCapture: true})
-      }
-    },
-    mouseUp: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onMouseUp: true}),
-        captured: keyOf({onMouseUpCapture: true})
-      }
-    },
-    mouseMove: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onMouseMove: true}),
-        captured: keyOf({onMouseMoveCapture: true})
-      }
-    },
-    doubleClick: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onDoubleClick: true}),
-        captured: keyOf({onDoubleClickCapture: true})
-      }
-    },
-    click: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onClick: true}),
-        captured: keyOf({onClickCapture: true})
-      }
-    },
-    mouseWheel: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onMouseWheel: true}),
-        captured: keyOf({onMouseWheelCapture: true})
-      }
-    },
-    touchStart: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onTouchStart: true}),
-        captured: keyOf({onTouchStartCapture: true})
-      }
-    },
-    touchEnd: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onTouchEnd: true}),
-        captured: keyOf({onTouchEndCapture: true})
-      }
-    },
-    touchCancel: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onTouchCancel: true}),
-        captured: keyOf({onTouchCancelCapture: true})
-      }
-    },
-    touchMove: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onTouchMove: true}),
-        captured: keyOf({onTouchMoveCapture: true})
-      }
-    },
-    keyUp: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onKeyUp: true}),
-        captured: keyOf({onKeyUpCapture: true})
-      }
-    },
-    keyPress: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onKeyPress: true}),
-        captured: keyOf({onKeyPressCapture: true})
-      }
-    },
-    keyDown: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onKeyDown: true}),
-        captured: keyOf({onKeyDownCapture: true})
-      }
-    },
-    focus: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onFocus: true}),
-        captured: keyOf({onFocusCapture: true})
-      }
-    },
-    blur: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onBlur: true}),
-        captured: keyOf({onBlurCapture: true})
-      }
-    },
-    scroll: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onScroll: true}),
-        captured: keyOf({onScrollCapture: true})
-      }
-    },
-    change: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onChange: true}),
-        captured: keyOf({onChangeCapture: true})
-      }
-    },
-    submit: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onSubmit: true}),
-        captured: keyOf({onSubmitCapture: true})
-      }
-    },
-    DOMCharacterDataModified: {
-      phasedRegistrationNames: {
-        bubbled: keyOf({onDOMCharacterDataModified: true}),
-        captured: keyOf({onDOMCharacterDataModifiedCapture: true})
-      }
-    }
-  },
-
-  /**
-   * Same as the default implementation, except cancels the event when return
-   * value is false.
-   * @param {AbstractEvent} AbstractEvent to handle
-   * @param {function} Application-level callback
-   * @param {string} domID DOM id to pass to the callback.
-   */
-  executeDispatch: function(abstractEvent, listener, domID) {
-    var returnValue = listener(abstractEvent, domID);
-    if (returnValue === false) {
-      abstractEvent.stopPropagation();
-      abstractEvent.preventDefault();
-    }
-  },
-
-  /**
-   * @see EventPluginHub.extractAbstractEvents
-   */
-  extractAbstractEvents:
-    function(topLevelType, nativeEvent, renderedTargetID, renderedTarget) {
-      var data;
-      var abstractEventType =
-        SimpleEventPlugin.topLevelTypesToAbstract[topLevelType];
-      if (!abstractEventType) {
-        return null;
-      }
-      switch(topLevelType) {
-        case topLevelTypes.topMouseWheel:
-          data = AbstractEvent.normalizeMouseWheelData(nativeEvent);
-          break;
-        case topLevelTypes.topScroll:
-          data = AbstractEvent.normalizeScrollDataFromTarget(renderedTarget);
-          break;
-        case topLevelTypes.topClick:
-        case topLevelTypes.topDoubleClick:
-        case topLevelTypes.topChange:
-        case topLevelTypes.topDOMCharacterDataModified:
-        case topLevelTypes.topMouseDown:
-        case topLevelTypes.topMouseUp:
-        case topLevelTypes.topMouseMove:
-        case topLevelTypes.topTouchMove:
-        case topLevelTypes.topTouchStart:
-        case topLevelTypes.topTouchEnd:
-          data = AbstractEvent.normalizePointerData(nativeEvent);
-          break;
-        default:
-          data = null;
-      }
-      var abstractEvent = AbstractEvent.getPooled(
-        abstractEventType,
-        renderedTargetID,
-        topLevelType,
-        nativeEvent,
-        data
-      );
-      EventPropagators.accumulateTwoPhaseDispatches(abstractEvent);
-      return abstractEvent;
-    }
-};
-
-SimpleEventPlugin.topLevelTypesToAbstract = {
-  topMouseDown:   SimpleEventPlugin.abstractEventTypes.mouseDown,
-  topMouseUp:     SimpleEventPlugin.abstractEventTypes.mouseUp,
-  topMouseMove:   SimpleEventPlugin.abstractEventTypes.mouseMove,
-  topClick:       SimpleEventPlugin.abstractEventTypes.click,
-  topDoubleClick: SimpleEventPlugin.abstractEventTypes.doubleClick,
-  topMouseWheel:  SimpleEventPlugin.abstractEventTypes.mouseWheel,
-  topTouchStart:  SimpleEventPlugin.abstractEventTypes.touchStart,
-  topTouchEnd:    SimpleEventPlugin.abstractEventTypes.touchEnd,
-  topTouchMove:   SimpleEventPlugin.abstractEventTypes.touchMove,
-  topTouchCancel: SimpleEventPlugin.abstractEventTypes.touchCancel,
-  topKeyUp:       SimpleEventPlugin.abstractEventTypes.keyUp,
-  topKeyPress:    SimpleEventPlugin.abstractEventTypes.keyPress,
-  topKeyDown:     SimpleEventPlugin.abstractEventTypes.keyDown,
-  topFocus:       SimpleEventPlugin.abstractEventTypes.focus,
-  topBlur:        SimpleEventPlugin.abstractEventTypes.blur,
-  topScroll:      SimpleEventPlugin.abstractEventTypes.scroll,
-  topChange:      SimpleEventPlugin.abstractEventTypes.change,
-  topSubmit:      SimpleEventPlugin.abstractEventTypes.submit,
-  topDOMCharacterDataModified:
-                  SimpleEventPlugin.abstractEventTypes.DOMCharacterDataModified
-};
-
-module.exports = SimpleEventPlugin;
diff --git a/React/TapEventPlugin.js b/React/TapEventPlugin.js
deleted file mode 100644
index 9d9b130769..0000000000
--- a/React/TapEventPlugin.js
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule TapEventPlugin
- */
-
-"use strict";
-
-var AbstractEvent = require("./AbstractEvent");
-var EventPluginUtils = require("./EventPluginUtils");
-var EventPropagators = require("./EventPropagators");
-
-var keyOf = require("./keyOf");
-
-var isStartish = EventPluginUtils.isStartish;
-var isEndish = EventPluginUtils.isEndish;
-var storePageCoordsIn = EventPluginUtils.storePageCoordsIn;
-var eventDistance = EventPluginUtils.eventDistance;
-
-/**
- * The number of pixels that are tolerated in between a touchStart and
- * touchEnd in order to still be considered a 'tap' event.
- */
-var tapMoveThreshold = 10;
-var startCoords = {x: null, y: null};
-
-var abstractEventTypes = {
-  touchTap: {
-    phasedRegistrationNames: {
-      bubbled: keyOf({onTouchTap: null}),
-      captured: keyOf({onTouchTapCapture: null})
-    }
-  }
-};
-
-/**
- * @see EventPluginHub.extractAbstractEvents
- */
-var extractAbstractEvents = function(
-    topLevelType,
-    nativeEvent,
-    renderedTargetID,
-    renderedTarget) {
-
-  if (!isStartish(topLevelType) && !isEndish(topLevelType)) {
-    return;
-  }
-  var abstractEvent;
-  var dist = eventDistance(startCoords, nativeEvent);
-  if (isEndish(topLevelType) && dist < tapMoveThreshold) {
-    var type = abstractEventTypes.touchTap;
-    var abstractTargetID = renderedTargetID;
-    abstractEvent = AbstractEvent.getPooled(
-      type,
-      abstractTargetID,
-      topLevelType,
-      nativeEvent
-    );
-  }
-  if (isStartish(topLevelType)) {
-    storePageCoordsIn(startCoords, nativeEvent);
-  } else if (isEndish(topLevelType)) {
-    startCoords.x = 0;
-    startCoords.y = 0;
-  }
-  EventPropagators.accumulateTwoPhaseDispatches(abstractEvent);
-  return abstractEvent;
-};
-
-var TapEventPlugin = {
-  tapMoveThreshold: tapMoveThreshold,
-  startCoords: startCoords,
-  abstractEventTypes: abstractEventTypes,
-  extractAbstractEvents: extractAbstractEvents
-};
-
-module.exports = TapEventPlugin;
diff --git a/React/TouchEventUtils.js b/React/TouchEventUtils.js
deleted file mode 100644
index e99fada2c4..0000000000
--- a/React/TouchEventUtils.js
+++ /dev/null
@@ -1,42 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule TouchEventUtils
- */
-
-var TouchEventUtils = {
-  /**
-   * Utility function for common case of extracting out the primary touch from a
-   * touch event.
-   * - `touchEnd` events usually do not have the `touches` property.
-   *   http://stackoverflow.com/questions/3666929/
-   *   mobile-sarai-touchend-event-not-firing-when-last-touch-is-removed
-   *
-   * @param {Event} nativeEvent Native event that may or may not be a touch.
-   * @return {TouchesObject?} an object with pageX and pageY or null.
-   */
-  extractSingleTouch: function(nativeEvent) {
-    var touches = nativeEvent.touches;
-    var changedTouches = nativeEvent.changedTouches;
-    var hasTouches = touches && touches.length > 0;
-    var hasChangedTouches = changedTouches && changedTouches.length > 0;
-
-    return !hasTouches && hasChangedTouches ? changedTouches[0] :
-           hasTouches ? touches[0] :
-           nativeEvent;
-  }
-};
-
-module.exports = TouchEventUtils;
diff --git a/React/Transaction.js b/React/Transaction.js
deleted file mode 100644
index c84979f7e4..0000000000
--- a/React/Transaction.js
+++ /dev/null
@@ -1,252 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule Transaction
- */
-
-"use strict";
-
-var throwIf = require("./throwIf");
-
-var DUAL_TRANSACTION = 'DUAL_TRANSACTION';
-var MISSING_TRANSACTION = 'MISSING_TRANSACTION';
-if (true) {
-  DUAL_TRANSACTION =
-    'Cannot initialize transaction when there is already an outstanding ' +
-    'transaction. Common causes of this are trying to render a component ' +
-    'when you are already rendering a component or attempting a state ' +
-    'transition while in a render function. Another possibility is that ' +
-    'you are rendering new content (or state transitioning) in a ' +
-    'componentDidRender callback. If this is not the case, please report the ' +
-    'issue immediately.';
-
-  MISSING_TRANSACTION =
-    'Cannot close transaction when there is none open.';
-}
-
-/**
- * `Transaction` creates a black box that is able to wrap any method such that
- * certain invariants are maintained before and after the method is invoked
- * (Even if an exception is thrown while invoking the wrapped method). Whoever
- * instantiates a transaction can provide enforcers of the invariants at
- * creation time. The `Transaction` class itself will supply one additional
- * automatic invariant for you - the invariant that any transaction instance
- * should not be ran while it is already being ran. You would typically create a
- * single instance of a `Transaction` for reuse multiple times, that potentially
- * is used to wrap several different methods. Wrappers are extremely simple -
- * they only require implementing two methods.
- *
- * <pre>
- *                       wrappers (injected at creation time)
- *                                      +        +
- *                                      |        |
- *                    +-----------------|--------|--------------+
- *                    |                 v        |              |
- *                    |      +---------------+   |              |
- *                    |   +--|    wrapper1   |---|----+         |
- *                    |   |  +---------------+   v    |         |
- *                    |   |          +-------------+  |         |
- *                    |   |     +----|   wrapper2  |--------+   |
- *                    |   |     |    +-------------+  |     |   |
- *                    |   |     |                     |     |   |
- *                    |   v     v                     v     v   | wrapper
- *                    | +---+ +---+   +---------+   +---+ +---+ | invariants
- * perform(anyMethod) | |   | |   |   |         |   |   | |   | | maintained
- * +----------------->|-|---|-|---|-->|anyMethod|---|---|-|---|-|-------->
- *                    | |   | |   |   |         |   |   | |   | |
- *                    | |   | |   |   |         |   |   | |   | |
- *                    | |   | |   |   |         |   |   | |   | |
- *                    | +---+ +---+   +---------+   +---+ +---+ |
- *                    |  initialize                    close    |
- *                    +-----------------------------------------+
- * </pre>
- *
- * Bonus:
- * - Reports timing metrics by method name and wrapper index.
- *
- * Use cases:
- * - Preserving the input selection ranges before/after reconciliation.
- *   Restoring selection even in the event of an unexpected error.
- * - Deactivating events while rearranging the DOM, preventing blurs/focuses,
- *   while guaranteeing that afterwards, the event system is reactivated.
- * - Flushing a queue of collected DOM mutations to the main UI thread after a
- *   reconciliation takes place in a worker thread.
- * - Invoking any collected `componentDidRender` callbacks after rendering new
- *   content.
- * - (Future use case): Wrapping particular flushes of the `ReactWorker` queue
- *   to preserve the `scrollTop` (an automatic scroll aware DOM).
- * - (Future use case): Layout calculations before and after DOM upates.
- *
- * Transactional plugin API:
- * - A module that has an `initialize` method that returns any precomputation.
- * - and a `close` method that accepts the precomputation. `close` is invoked
- *   when the wrapped process is completed, or has failed.
- *
- * @param {Array<TransactionalWrapper>} transactionWrapper Wrapper modules
- * that implement `initialize` and `close`.
- * @return {Transaction} Single transaction for reuse in thread.
- *
- * @class Transaction
- */
-var Mixin = {
-  /**
-   * Sets up this instance so that it is prepared for collecting metrics. Does
-   * so such that this setup method may be used on an instance that is already
-   * initialized, in a way that does not consume additional memory upon reuse.
-   * That can be useful if you decide to make your subclass of this mixin a
-   * "PooledClass".
-   */
-  reinitializeTransaction: function() {
-    this.transactionWrappers = this.getTransactionWrappers();
-    if (!this.wrapperInitData) {
-      this.wrapperInitData = [];
-    } else {
-      this.wrapperInitData.length = 0;
-    }
-    if (!this.timingMetrics) {
-      this.timingMetrics = {};
-    }
-    this.timingMetrics.methodInvocationTime = 0;
-    if (!this.timingMetrics.wrapperInitTimes) {
-      this.timingMetrics.wrapperInitTimes = [];
-    } else {
-      this.timingMetrics.wrapperInitTimes.length = 0;
-    }
-    if (!this.timingMetrics.wrapperCloseTimes) {
-      this.timingMetrics.wrapperCloseTimes = [];
-    } else {
-      this.timingMetrics.wrapperCloseTimes.length = 0;
-    }
-    this._isInTransaction = false;
-  },
-
-  _isInTransaction: false,
-
-  /**
-   * @abstract
-   * @return {Array<TransactionWrapper>} Array of transaction wrappers.
-   */
-  getTransactionWrappers: null,
-
-  isInTransaction: function() {
-    return !!this._isInTransaction;
-  },
-
-  /**
-   * Executes the function within a safety window. Use this for the top level
-   * methods that result in large amounts of computation/mutations that would
-   * need to be safety checked.
-   *
-   * @param {function} method Member of scope to call.
-   * @param {Object} scope Scope to invoke from.
-   * @param {Object?=} args... Arguments to pass to the method (optional).
-   *                           Helps prevent need to bind in many cases.
-   * @returns Return value from `method`.
-   */
-  perform: function(method, scope, a, b, c, d, e, f) {
-    throwIf(this.isInTransaction(), DUAL_TRANSACTION);
-    var memberStart = Date.now();
-    var err = null;
-    var ret;
-    try {
-      this.initializeAll();
-      ret = method.call(scope, a, b, c, d, e, f);
-    } catch (ie_requires_catch) {
-      err = ie_requires_catch;
-    } finally {
-      var memberEnd = Date.now();
-      this.methodInvocationTime += (memberEnd - memberStart);
-      try {
-        this.closeAll();
-      } catch (closeAllErr) {
-        err = err || closeAllErr;
-      }
-    }
-    if (err) {
-      throw err;
-    }
-    return ret;
-  },
-
-  initializeAll: function() {
-    this._isInTransaction = true;
-    var transactionWrappers = this.transactionWrappers;
-    var wrapperInitTimes = this.timingMetrics.wrapperInitTimes;
-    var err = null;
-    for (var i = 0; i < transactionWrappers.length; i++) {
-      var initStart = Date.now();
-      var wrapper = transactionWrappers[i];
-      try {
-        this.wrapperInitData[i] =
-          wrapper.initialize ? wrapper.initialize.call(this) : null;
-      } catch (initErr) {
-        err = err || initErr;  // Remember the first error.
-        this.wrapperInitData[i] = Transaction.OBSERVED_ERROR;
-      } finally {
-        var curInitTime = wrapperInitTimes[i];
-        var initEnd = Date.now();
-        wrapperInitTimes[i] = (curInitTime || 0) + (initEnd - initStart);
-      }
-    }
-    if (err) {
-      throw err;
-    }
-  },
-
-  /**
-   * Invokes each of `this.transactionWrappers.close[i]` functions, passing into
-   * them the respective return values of `this.transactionWrappers.init[i]`
-   * (`close`rs that correspond to initializers that failed will not be
-   * invoked).
-   */
-  closeAll: function() {
-    throwIf(!this.isInTransaction(), MISSING_TRANSACTION);
-    var transactionWrappers = this.transactionWrappers;
-    var wrapperCloseTimes = this.timingMetrics.wrapperCloseTimes;
-    var err = null;
-    for (var i = 0; i < transactionWrappers.length; i++) {
-      var wrapper = transactionWrappers[i];
-      var closeStart = Date.now();
-      var initData = this.wrapperInitData[i];
-      try {
-        if (initData !== Transaction.OBSERVED_ERROR) {
-          wrapper.close && wrapper.close.call(this, initData);
-        }
-      } catch (closeErr) {
-        err = err || closeErr;  // Remember the first error.
-      } finally {
-        var closeEnd = Date.now();
-        var curCloseTime = wrapperCloseTimes[i];
-        wrapperCloseTimes[i] = (curCloseTime || 0) + (closeEnd - closeStart);
-      }
-    }
-    this.wrapperInitData.length = 0;
-    this._isInTransaction = false;
-    if (err) {
-      throw err;
-    }
-  }
-};
-
-var Transaction = {
-  Mixin: Mixin,
-  /**
-   * Token to look for to determine if an error occured.
-   */
-  OBSERVED_ERROR: {}
-
-};
-
-module.exports = Transaction;
diff --git a/React/accumulate.js b/React/accumulate.js
deleted file mode 100644
index 14b3a0467f..0000000000
--- a/React/accumulate.js
+++ /dev/null
@@ -1,70 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule accumulate
- */
-
-"use strict";
-
-var throwIf = require("./throwIf");
-
-var INVALID_ARGS = 'INVALID_ACCUM_ARGS';
-
-if (true) {
-  INVALID_ARGS =
-    'accumulate requires non empty (non-null, defined) next ' +
-    'values. All arrays accumulated must not contain any empty items.';
-}
-
-/**
- * Accumulates items that must never be empty, into a result in a manner that
- * conserves memory - avoiding allocation of arrays until they are needed. The
- * accumulation may start and/or end up being a single element or an array
- * depending on the total count (if greater than one, an array is allocated).
- * Handles most common case first (starting with an empty current value and
- * acquiring one).
- * @returns {Accumulation} An accumulation which is either a single item or an
- * Array of items.
- */
-function accumulate(cur, next) {
-  var curValIsEmpty = cur == null;   // Will test for emptiness (null/undef)
-  var nextValIsEmpty = next === null;
-  if (true) {
-    throwIf(nextValIsEmpty, INVALID_ARGS);
-  }
-  if (nextValIsEmpty) {
-    return cur;
-  } else {
-    if (curValIsEmpty) {
-      return next;
-    } else {
-      // Both are not empty. Warning: Never call x.concat(y) when you are not
-      // certain that x is an Array (x could be a string with concat method).
-      var curIsArray = Array.isArray(cur);
-      var nextIsArray = Array.isArray(next);
-      if (curIsArray) {
-        return cur.concat(next);
-      } else {
-        if (nextIsArray) {
-          return [cur].concat(next);
-        } else {
-          return [cur, next];
-        }
-      }
-    }
-  }
-}
-
-module.exports = accumulate;
diff --git a/React/copyProperties.js b/React/copyProperties.js
deleted file mode 100644
index 4bbb9018b7..0000000000
--- a/React/copyProperties.js
+++ /dev/null
@@ -1,54 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule copyProperties
- */
-
-/**
- * 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.
- *
- * NOTE: `arguments` has a very significant performance penalty, which is why
- * we don't support unlimited arguments.
- */
-function copyProperties(obj, a, b, c, d, e, f) {
-  obj = obj || {};
-
-  if (true) {
-    if (f) {
-      throw new Error('Too many arguments passed to copyProperties');
-    }
-  }
-
-  var args = [a, b, c, d, e];
-  var ii = 0, v;
-  while (args[ii]) {
-    v = args[ii++];
-    for (var k in v) {
-      obj[k] = v[k];
-    }
-
-    // IE ignores toString in object iteration.. See:
-    // webreflection.blogspot.com/2007/07/quick-fix-internet-explorer-and.html
-    if (v.hasOwnProperty && v.hasOwnProperty('toString') &&
-        (typeof v.toString != 'undefined') && (obj.toString !== v.toString)) {
-      obj.toString = v.toString;
-    }
-  }
-
-  return obj;
-}
-
-module.exports = copyProperties;
diff --git a/React/core/__tests__/ReactBind-test.js b/React/core/__tests__/ReactBind-test.js
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/React/core/__tests__/ReactComponent-test.js b/React/core/__tests__/ReactComponent-test.js
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/React/core/__tests__/ReactComponentFlattenChildren-test.js b/React/core/__tests__/ReactComponentFlattenChildren-test.js
deleted file mode 100644
index 06460f725d..0000000000
--- a/React/core/__tests__/ReactComponentFlattenChildren-test.js
+++ /dev/null
@@ -1 +0,0 @@
-throw new Error("nonexistent module required: core/__tests__/ReactComponentFlattenChildren-test");
\ No newline at end of file
diff --git a/React/core/__tests__/ReactComponentLifeCycle-test.js b/React/core/__tests__/ReactComponentLifeCycle-test.js
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/React/core/__tests__/ReactCompositeComponent-test.js b/React/core/__tests__/ReactCompositeComponent-test.js
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/React/core/__tests__/ReactCompositeComponentDOMMinimalism-test.js b/React/core/__tests__/ReactCompositeComponentDOMMinimalism-test.js
deleted file mode 100644
index a7108e0fd7..0000000000
--- a/React/core/__tests__/ReactCompositeComponentDOMMinimalism-test.js
+++ /dev/null
@@ -1,113 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @jsx React.DOM
- * @emails react-core
- */
-
-"use strict";
-
-// Requires
-var React;
-var ReactTestUtils;
-var reactComponentExpect;
-
-// Test components
-var LowerLevelComposite;
-var MyCompositeComponent;
-
-var expectSingleChildlessDiv;
-
-/**
- * Integration test, testing the combination of JSX with our unit of
- * abstraction, `ReactCompositeComponent` does not ever add superfluous DOM
- * nodes.
- */
-describe('ReactCompositeComponentDOMMinimalism', function() {
-
-  beforeEach(function() {
-    reactComponentExpect = require("../../reactComponentExpect");
-    React = require("../../React");
-    ReactTestUtils = require("../../ReactTestUtils");
-
-    LowerLevelComposite = React.createClass({
-      render: function() {
-        return (
-          React.DOM.div(null, 
-            this.props.children
-          )
-        );
-      }
-    });
-
-    MyCompositeComponent = React.createClass({
-      render: function() {
-        return (
-          LowerLevelComposite(null, 
-            this.props.children
-          )
-        );
-      }
-    });
-
-    expectSingleChildlessDiv = function(instance) {
-      reactComponentExpect(instance)
-        .expectRenderedChild()
-        .toBeCompositeComponentWithType(LowerLevelComposite)
-          .expectRenderedChild()
-          .toBeDOMComponentWithTag('div')
-          .toBeDOMComponentWithNoChildren();
-    };
-  });
-
-  it('should not render extra nodes for non-interpolated text', function() {
-    var instance = (
-      MyCompositeComponent(null, 
-" A string child "      )
-    );
-    ReactTestUtils.renderIntoDocument(instance);
-    expectSingleChildlessDiv(instance);
-  });
-
-  it('should not render extra nodes for non-interpolated text', function() {
-    var instance = (
-      MyCompositeComponent(null, 
-        'Interpolated String Child'
-      )
-    );
-    ReactTestUtils.renderIntoDocument(instance);
-    expectSingleChildlessDiv(instance);
-  });
-
-  it('should not render extra nodes for non-interpolated text', function() {
-    var instance = (
-      MyCompositeComponent(null, 
-        React.DOM.ul(null, 
-" This text causes no children in ul, just innerHTML "        )
-      )
-    );
-    ReactTestUtils.renderIntoDocument(instance);
-    reactComponentExpect(instance)
-      .expectRenderedChild()
-      .toBeCompositeComponentWithType(LowerLevelComposite)
-        .expectRenderedChild()
-        .toBeDOMComponentWithTag('div')
-        .toBeDOMComponentWithChildCount(1)
-        .expectRenderedChildAt(0)
-          .toBeDOMComponentWithTag('ul')
-          .toBeDOMComponentWithNoChildren();
-  });
-
-});
diff --git a/React/core/__tests__/ReactCompositeComponentMixin-test.js b/React/core/__tests__/ReactCompositeComponentMixin-test.js
deleted file mode 100644
index 2e2842a235..0000000000
--- a/React/core/__tests__/ReactCompositeComponentMixin-test.js
+++ /dev/null
@@ -1,82 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @jsx React.DOM
- * @emails react-core
- */
-
-"use strict";
-
-var mocks = require("../../mocks");
-
-var React;
-var ReactTestUtils;
-var reactComponentExpect;
-
-var TestComponent;
-
-describe('ReactCompositeComponent-mixin', function() {
-
-  beforeEach(function() {
-    React = require("../../React");
-    ReactTestUtils = require("../../ReactTestUtils");
-    reactComponentExpect = require("../../reactComponentExpect");
-
-    var MixinA = {
-      componentDidMount: function() {
-        this.props.listener('MixinA didMount');
-      }
-    };
-
-    var MixinB = {
-      mixins: [MixinA],
-      componentDidMount: function() {
-        this.props.listener('MixinB didMount');
-      }
-    };
-
-    var MixinC = {
-      componentDidMount: function() {
-        this.props.listener('MixinC didMount');
-      }
-    };
-
-    TestComponent = React.createClass({
-      mixins: [MixinB, MixinC],
-
-      componentDidMount: function() {
-        this.props.listener('Component didMount');
-      },
-
-      render: function() {
-        return React.DOM.div(null, null );
-      }
-    });
-
-  });
-
-  it('should support chaining delegate functions', function() {
-    var listener = mocks.getMockFunction();
-    var instance = TestComponent( {listener:listener}, null );
-    ReactTestUtils.renderIntoDocument(instance);
-
-    expect(listener.mock.calls).toEqual([
-      ['MixinA didMount'],
-      ['MixinB didMount'],
-      ['MixinC didMount'],
-      ['Component didMount']
-    ]);
-  });
-});
diff --git a/React/core/__tests__/ReactCompositeComponentSpec-test.js b/React/core/__tests__/ReactCompositeComponentSpec-test.js
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/React/core/__tests__/ReactCompositeComponentState-test.js b/React/core/__tests__/ReactCompositeComponentState-test.js
deleted file mode 100644
index 3ce0f47ba1..0000000000
--- a/React/core/__tests__/ReactCompositeComponentState-test.js
+++ /dev/null
@@ -1,169 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @jsx React.DOM
- * @emails react-core
- */
-
-"use strict";
-
-var mocks = require("../../mocks");
-
-var React;
-var ReactTestUtils;
-var reactComponentExpect;
-
-var TestComponent;
-
-describe('ReactCompositeComponent-state', function() {
-
-  beforeEach(function() {
-    React = require("../../React");
-    ReactTestUtils = require("../../ReactTestUtils");
-    reactComponentExpect = require("../../reactComponentExpect");
-
-    TestComponent = React.createClass({
-      peekAtState: function(from, state) {
-        if (state) {
-          this.props.stateListener(from, state && state.color);
-        } else {
-          this.props.stateListener(
-            from,
-            this.state && this.state.color,
-            this._pendingState && this._pendingState.color
-          );
-        }
-      },
-
-      setFavoriteColor: function(nextColor) {
-        this.setState({color: nextColor});
-      },
-
-      getInitialState: function() {
-        this.peekAtState('getInitialState');
-        return {color: 'red'};
-      },
-
-      render: function() {
-        this.peekAtState('render');
-        return React.DOM.div(null, this.state.color);
-      },
-
-      componentWillMount: function() {
-        this.peekAtState('componentWillMount-start');
-        this.setState({color: 'sunrise'});
-        this.peekAtState('componentWillMount-after-sunrise');
-        this.setState({color: 'orange'});
-        this.peekAtState('componentWillMount-end');
-      },
-
-      componentDidMount: function() {
-        this.peekAtState('componentDidMount-start');
-        this.setState({color: 'yellow'});
-        this.peekAtState('componentDidMount-end');
-      },
-
-      componentWillReceiveProps: function(newProps) {
-        this.peekAtState('componentWillReceiveProps-start');
-        if (newProps.nextColor) {
-          this.setState({color: newProps.nextColor});
-        }
-        this.peekAtState('componentWillReceiveProps-end');
-      },
-
-      shouldComponentUpdate: function(nextProps, nextState) {
-        this.peekAtState('shouldComponentUpdate-currentState');
-        this.peekAtState('shouldComponentUpdate-nextState', nextState);
-        return true;
-      },
-
-      componentWillUpdate: function(nextProps, nextState) {
-        this.peekAtState('componentWillUpdate-currentState');
-        this.peekAtState('componentWillUpdate-nextState', nextState);
-      },
-
-      componentDidUpdate: function(prevProps, prevState) {
-        this.peekAtState('componentDidUpdate-currentState');
-        this.peekAtState('componentDidUpdate-prevState', prevState);
-      },
-
-      componentWillUnmount: function() {
-        this.peekAtState('componentWillUnmount');
-      }
-    });
-
-  });
-
-  it('should support setting state', function() {
-    var stateListener = mocks.getMockFunction();
-    var instance = TestComponent( {stateListener:stateListener}, null );
-    ReactTestUtils.renderIntoDocument(instance);
-    instance.setProps({nextColor: 'green'});
-    instance.setFavoriteColor('blue');
-    instance.forceUpdate();
-    instance.unmountComponent();
-
-    expect(stateListener.mock.calls).toEqual([
-      // there is no state when getInitialState() is called
-      [ 'getInitialState', null, null ],
-      [ 'componentWillMount-start', 'red', null ],
-      // setState() only enqueues a pending state.
-      [ 'componentWillMount-after-sunrise', 'red', 'sunrise' ],
-      [ 'componentWillMount-end', 'red', 'orange' ],
-      // pending state has been applied
-      [ 'render', 'orange', null ],
-      [ 'componentDidMount-start', 'orange', null ],
-      // componentDidMount() called setState({color:'yellow'}), currently this
-      // occurs inline.
-      // In a future where setState() is async, this test result will change.
-      [ 'shouldComponentUpdate-currentState', 'orange', null ],
-      [ 'shouldComponentUpdate-nextState', 'yellow' ],
-      [ 'componentWillUpdate-currentState', 'orange', null ],
-      [ 'componentWillUpdate-nextState', 'yellow' ],
-      [ 'render', 'yellow', null ],
-      [ 'componentDidUpdate-currentState', 'yellow', null ],
-      [ 'componentDidUpdate-prevState', 'orange' ],
-      // componentDidMount() finally closes.
-      [ 'componentDidMount-end', 'yellow', null ],
-      [ 'componentWillReceiveProps-start', 'yellow', null ],
-      // setState({color:'green'}) only enqueues a pending state.
-      [ 'componentWillReceiveProps-end', 'yellow', 'green' ],
-      [ 'shouldComponentUpdate-currentState', 'yellow', null ],
-      [ 'shouldComponentUpdate-nextState', 'green' ],
-      [ 'componentWillUpdate-currentState', 'yellow', null ],
-      [ 'componentWillUpdate-nextState', 'green' ],
-      [ 'render', 'green', null ],
-      [ 'componentDidUpdate-currentState', 'green', null ],
-      [ 'componentDidUpdate-prevState', 'yellow' ],
-      // setFavoriteColor('blue')
-      [ 'shouldComponentUpdate-currentState', 'green', null ],
-      [ 'shouldComponentUpdate-nextState', 'blue' ],
-      [ 'componentWillUpdate-currentState', 'green', null ],
-      [ 'componentWillUpdate-nextState', 'blue' ],
-      [ 'render', 'blue', null ],
-      [ 'componentDidUpdate-currentState', 'blue', null ],
-      [ 'componentDidUpdate-prevState', 'green' ],
-      // forceUpdate()
-      [ 'componentWillUpdate-currentState', 'blue', null ],
-      [ 'componentWillUpdate-nextState', 'blue' ],
-      [ 'render', 'blue', null ],
-      [ 'componentDidUpdate-currentState', 'blue', null ],
-      [ 'componentDidUpdate-prevState', 'blue' ],
-      // unmountComponent()
-      // state is available within `componentWillUnmount()`
-      [ 'componentWillUnmount', 'blue', null ]
-    ]);
-  });
-});
diff --git a/React/core/__tests__/ReactCompositeComponentTransferProps-test.js b/React/core/__tests__/ReactCompositeComponentTransferProps-test.js
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/React/core/__tests__/ReactDOM-test.js b/React/core/__tests__/ReactDOM-test.js
deleted file mode 100644
index 24cb0c90f5..0000000000
--- a/React/core/__tests__/ReactDOM-test.js
+++ /dev/null
@@ -1,112 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @jsx React.DOM
- * @emails react-core
- */
-
-"use strict";
-
-var React = require("../../React");
-var ReactDOM = require("../../ReactDOM");
-var ReactTestUtils = require("../../ReactTestUtils");
-var React = require("../../React");
-
-describe('ref swapping', function() {
-  // TODO: uncomment this test once we can run in phantom, which
-  // supports real submit events.
-  /*
-  it('should bubble onSubmit', function() {
-    var count = 0;
-    var form;
-    var Parent = React.createClass({
-      handleSubmit: function() {
-        count++;
-        return false;
-      },
-      render: function() {
-        return <Child />;
-      }
-    });
-    var Child = React.createClass({
-      render: function() {
-        return <form><input type="submit" value="Submit" /></form>;
-      },
-      componentDidMount: function(node) {
-        form = node;
-      }
-    });
-    var instance = ReactTestUtils.renderIntoDocument(<Parent />);
-    form.submit();
-    expect(count).toEqual(1);
-  });
-  */
-
-  it("should allow children to be passed as an argument", function() {
-    var argDiv = ReactTestUtils.renderIntoDocument(
-      ReactDOM.div(null, 'child')
-    );
-    var argNode = document.getElementById(argDiv._rootNodeID);
-    expect(argNode.innerHTML).toBe('child');
-  });
-
-  it("should overwrite props.children with children argument", function() {
-    var conflictDiv = ReactTestUtils.renderIntoDocument(
-      ReactDOM.div({children: 'fakechild'}, 'child')
-    );
-    var conflictNode = document.getElementById(conflictDiv._rootNodeID);
-    expect(conflictNode.innerHTML).toBe('child');
-  });
-
-  /**
-   * We need to make sure that updates occur to the actual node that's in the
-   * DOM, instead of a stale cache.
-   */
-  it("should purge the DOM cache when removing nodes", function() {
-    var myDiv = ReactTestUtils.renderIntoDocument(
-      React.DOM.div(null, {
-        theDog: React.DOM.div( {className:"dog"}, null ),
-        theBird: React.DOM.div( {className:"bird"}, null )
-      })
-    );
-    myDiv.setProps({
-      children: {
-        theDog: React.DOM.div( {className:"dogbeforedelete"}, null ),  // Warm the cache with theDog
-        theBird: React.DOM.div( {className:"bird"}, null )
-      }
-    });
-    myDiv.setProps({
-      children: {                                 // This better purge that cache
-        theBird: React.DOM.div( {className:"bird"}, null )
-      }
-    });
-    // Now, put the dog back.
-    myDiv.setProps({
-      children: {
-        theDog: React.DOM.div( {className:"dog"}, null ),       // This is a different node than before
-        theBird: React.DOM.div( {className:"bird"}, null )
-      }
-    });
-    myDiv.setProps({
-      children: {                          // className changed to bigdog.
-        theDog: React.DOM.div( {className:"bigdog"}, null ),    // but will it use the proper element
-        theBird: React.DOM.div( {className:"bird"}, null )
-      }
-    });
-    var root = document.getElementById(myDiv._rootNodeID);
-    var dog = root.childNodes[0];
-    expect(dog.className).toBe('bigdog');
-  });
-});
diff --git a/React/core/__tests__/ReactDOMIDOperations-test.js b/React/core/__tests__/ReactDOMIDOperations-test.js
deleted file mode 100644
index fdabc900b7..0000000000
--- a/React/core/__tests__/ReactDOMIDOperations-test.js
+++ /dev/null
@@ -1,65 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @emails react-core
- */
-
-/*jslint evil: true */
-
-"use strict";
-
-describe('ReactDOMIDOperations', function() {
-  var DOMPropertyOperations = require("../../DOMPropertyOperations");
-  var ReactDOMIDOperations = require("../../ReactDOMIDOperations");
-  var ReactDOMNodeCache = require("../../ReactDOMNodeCache");
-  var keyOf = require("../../keyOf");
-
-  it('should disallow updating special properties', function() {
-    spyOn(ReactDOMNodeCache, "getCachedNodeByID");
-    spyOn(DOMPropertyOperations, "setValueForProperty");
-
-    expect(function() {
-      ReactDOMIDOperations.updatePropertyByID(
-        'testID',
-        keyOf({content: null}),
-        'testContent'
-      );
-    }).toThrow();
-
-    expect(
-      ReactDOMNodeCache.getCachedNodeByID.argsForCall[0][0]
-    ).toBe('testID');
-
-    expect(
-      DOMPropertyOperations.setValueForProperty.callCount
-    ).toBe(0);
-  });
-
-  it('should update innerHTML and special-case whitespace', function() {
-    var stubNode = document.createElement('div');
-    spyOn(ReactDOMNodeCache, "getCachedNodeByID").andReturn(stubNode);
-
-    ReactDOMIDOperations.updateInnerHTMLByID(
-      'testID',
-      {__html: ' testContent'}
-    );
-
-    expect(
-      ReactDOMNodeCache.getCachedNodeByID.argsForCall[0][0]
-    ).toBe('testID');
-
-    expect(stubNode.innerHTML).toBe('&nbsp;testContent');
-  });
-});
diff --git a/React/core/__tests__/ReactEvent-test.js b/React/core/__tests__/ReactEvent-test.js
deleted file mode 100644
index 71b2ecb717..0000000000
--- a/React/core/__tests__/ReactEvent-test.js
+++ /dev/null
@@ -1,335 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @emails react-core
- */
-
-"use strict";
-
-require("../../mock-modules")
-    .dontMock('BrowserScroll')
-    .dontMock('CallbackRegistry')
-    .dontMock('EventPluginHub')
-    .dontMock('ReactEvent')
-    .dontMock('ReactInstanceHandles')
-    .dontMock('EventPluginHub')
-    .dontMock('TapEventPlugin')
-    .dontMock('TouchEventUtils')
-    .dontMock('keyOf');
-
-
-var keyOf = require("../../keyOf");
-var mocks = require("../../mocks");
-
-var EventPluginHub;
-var ReactEvent;
-var ReactEventTopLevelCallback;
-var ReactTestUtils;
-var TapEventPlugin;
-
-var tapMoveThreshold;
-var idCallOrder = [];
-var recordID = function(id) {
-  idCallOrder.push(id);
-};
-var recordIDAndStopPropagation = function(id, event) {
-  recordID(id);
-  event.stopPropagation();
-};
-var recordIDAndReturnFalse = function(id, event) {
-  recordID(id);
-  return false;
-};
-var LISTENER = mocks.getMockFunction();
-var ON_CLICK_KEY = keyOf({onClick: null});
-var ON_TOUCH_TAP_KEY = keyOf({onTouchTap: null});
-
-
-/**
- * Since `ReactEvent` is fairly well separated from the DOM, we can test almost
- * all of `ReactEvent` without ever rendering anything in the DOM. As long as we
- * provide IDs that follow `React's` conventional id namespace hierarchy.
- * The only reason why we create these DOM nodes, is so that when we feed them
- * into `ReactEvent` (through `ReactTestUtils`), the event handlers may receive
- * a DOM node to inspect.
- */
-var CHILD = document.createElement('div');
-var PARENT = document.createElement('div');
-var GRANDPARENT = document.createElement('div');
-CHILD.id = '.reactRoot.[0].[0].[0]';
-PARENT.id = '.reactRoot.[0].[0]';
-GRANDPARENT.id = '.reactRoot.[0]';
-
-function registerSimpleTestHandler() {
-  ReactEvent.putListener(CHILD.id, ON_CLICK_KEY, LISTENER);
-  var listener = ReactEvent.getListener(CHILD.id, ON_CLICK_KEY);
-  expect(listener).toEqual(LISTENER);
-  return ReactEvent.getListener(CHILD.id, ON_CLICK_KEY);
-}
-
-
-describe('ReactEvent', function() {
-  beforeEach(function() {
-    require("../../mock-modules").dumpCache();
-    EventPluginHub = require("../../EventPluginHub");
-    TapEventPlugin = require("../../TapEventPlugin");
-    ReactEvent = require("../../ReactEvent");
-    ReactTestUtils = require("../../ReactTestUtils");
-    ReactEventTopLevelCallback = require("../../ReactEventTopLevelCallback");
-    idCallOrder = [];
-    tapMoveThreshold = TapEventPlugin.tapMoveThreshold;
-    ReactEvent.ensureListening(false, ReactEventTopLevelCallback);
-    EventPluginHub.injection.injectEventPluginsByName({
-      TapEventPlugin: TapEventPlugin
-    });
-  });
-
-  it('should store a listener correctly', function() {
-    registerSimpleTestHandler();
-    var listener = ReactEvent.getListener(CHILD.id, ON_CLICK_KEY);
-    expect(listener).toBe(LISTENER);
-  });
-
-  it('should retrieve a listener correctly', function() {
-    registerSimpleTestHandler();
-    var listener = ReactEvent.getListener(CHILD.id, ON_CLICK_KEY);
-    expect(listener).toEqual(LISTENER);
-  });
-
-  it('should clear all handlers when asked to', function() {
-    registerSimpleTestHandler();
-    ReactEvent.deleteAllListeners(CHILD.id);
-    var listener = ReactEvent.getListener(CHILD.id, ON_CLICK_KEY);
-    expect(listener).toBe(undefined);
-  });
-
-  it('should invoke a simple handler registered on a node', function() {
-    registerSimpleTestHandler();
-    ReactTestUtils.Simulate.click(CHILD);
-    expect(LISTENER.mock.calls.length).toBe(1);
-  });
-
-  it('should not invoke handlers when ReactEvent is disabled', function() {
-    registerSimpleTestHandler();
-    ReactEvent.setEnabled(false);
-    ReactTestUtils.Simulate.click(CHILD);
-    expect(LISTENER.mock.calls.length).toBe(0);
-    ReactEvent.setEnabled(true);
-    ReactTestUtils.Simulate.click(CHILD);
-    expect(LISTENER.mock.calls.length).toBe(1);
-  });
-
-  it('should bubble simply', function() {
-    ReactEvent.putListener(
-      CHILD.id,
-      ON_CLICK_KEY,
-      recordID.bind(null, CHILD.id)
-    );
-    ReactEvent.putListener(
-      PARENT.id,
-      ON_CLICK_KEY,
-      recordID.bind(null, PARENT.id)
-    );
-    ReactEvent.putListener(
-      GRANDPARENT.id,
-      ON_CLICK_KEY,
-      recordID.bind(null, GRANDPARENT.id)
-    );
-    ReactTestUtils.Simulate.click(CHILD);
-    expect(idCallOrder.length).toBe(3);
-    expect(idCallOrder[0]).toBe(CHILD.id);
-    expect(idCallOrder[1]).toBe(PARENT.id);
-    expect(idCallOrder[2]).toBe(GRANDPARENT.id);
-  });
-
-  it('should support stopPropagation()', function() {
-    ReactEvent.putListener(
-      CHILD.id,
-      ON_CLICK_KEY,
-      recordID.bind(null, CHILD.id)
-    );
-    ReactEvent.putListener(
-      PARENT.id,
-      ON_CLICK_KEY,
-      recordIDAndStopPropagation.bind(null, PARENT.id)
-    );
-    ReactEvent.putListener(
-      GRANDPARENT.id,
-      ON_CLICK_KEY,
-      recordID.bind(null, GRANDPARENT.id)
-    );
-    ReactTestUtils.Simulate.click(CHILD);
-    expect(idCallOrder.length).toBe(2);
-    expect(idCallOrder[0]).toBe(CHILD.id);
-    expect(idCallOrder[1]).toBe(PARENT.id);
-  });
-
-  it('should stop after first dispatch if stopPropagation', function() {
-    ReactEvent.putListener(
-      CHILD.id,
-      ON_CLICK_KEY,
-      recordIDAndStopPropagation.bind(null, CHILD.id)
-    );
-    ReactEvent.putListener(
-      PARENT.id,
-      ON_CLICK_KEY,
-      recordID.bind(null, PARENT.id)
-    );
-    ReactEvent.putListener(
-      GRANDPARENT.id,
-      ON_CLICK_KEY,
-      recordID.bind(null, GRANDPARENT.id)
-    );
-    ReactTestUtils.Simulate.click(CHILD);
-    expect(idCallOrder.length).toBe(1);
-    expect(idCallOrder[0]).toBe(CHILD.id);
-  });
-
-  it('should stopPropagation if false is returned', function() {
-    ReactEvent.putListener(
-      CHILD.id,
-      ON_CLICK_KEY,
-      recordIDAndReturnFalse.bind(null, CHILD.id)
-    );
-    ReactEvent.putListener(
-      PARENT.id,
-      ON_CLICK_KEY,
-      recordID.bind(null, PARENT.id)
-    );
-    ReactEvent.putListener(
-      GRANDPARENT.id,
-      ON_CLICK_KEY,
-      recordID.bind(null, GRANDPARENT.id)
-    );
-    ReactTestUtils.Simulate.click(CHILD);
-    expect(idCallOrder.length).toBe(1);
-    expect(idCallOrder[0]).toBe(CHILD.id);
-  });
-
-  /**
-   * The entire event registration state of the world should be "locked-in" at
-   * the time the event occurs. This is to resolve many edge cases that come
-   * about from a listener on a lower-in-DOM node causing structural changes at
-   * places higher in the DOM. If this lower-in-DOM node causes new content to
-   * be rendered at a place higher-in-DOM, we need to be careful not to invoke
-   * these new listeners.
-   */
-
-  it('should invoke handlers that were removed while bubbling', function() {
-    var handleParentClick = mocks.getMockFunction();
-    var handleChildClick = function(abstractEvent) {
-      ReactEvent.deleteAllListeners(PARENT.id);
-    };
-    ReactEvent.putListener(CHILD.id, ON_CLICK_KEY, handleChildClick);
-    ReactEvent.putListener(PARENT.id, ON_CLICK_KEY, handleParentClick);
-    ReactTestUtils.Simulate.click(CHILD);
-    expect(handleParentClick.mock.calls.length).toBe(1);
-  });
-
-  it('should not invoke newly inserted handlers while bubbling', function() {
-    var handleParentClick = mocks.getMockFunction();
-    var handleChildClick = function(abstractEvent) {
-      ReactEvent.putListener(PARENT.id, ON_CLICK_KEY, handleParentClick);
-    };
-    ReactEvent.putListener(CHILD.id, ON_CLICK_KEY, handleChildClick);
-    ReactTestUtils.Simulate.click(CHILD);
-    expect(handleParentClick.mock.calls.length).toBe(0);
-  });
-
-  it('should infer onTouchTap from a touchStart/End', function() {
-    ReactEvent.putListener(
-      CHILD.id,
-      ON_TOUCH_TAP_KEY,
-      recordID.bind(null, CHILD.id)
-    );
-    ReactTestUtils.Simulate.touchStart(
-      CHILD,
-      ReactTestUtils.nativeTouchData(0, 0)
-    );
-    ReactTestUtils.Simulate.touchEnd(
-      CHILD,
-      ReactTestUtils.nativeTouchData(0, 0)
-    );
-    expect(idCallOrder.length).toBe(1);
-    expect(idCallOrder[0]).toBe(CHILD.id);
-  });
-
-  it('should infer onTouchTap from when dragging below threshold', function() {
-    ReactEvent.putListener(
-      CHILD.id,
-      ON_TOUCH_TAP_KEY,
-      recordID.bind(null, CHILD.id)
-    );
-    ReactTestUtils.Simulate.touchStart(
-      CHILD,
-      ReactTestUtils.nativeTouchData(0, 0)
-    );
-    ReactTestUtils.Simulate.touchEnd(
-      CHILD,
-      ReactTestUtils.nativeTouchData(0, tapMoveThreshold - 1)
-    );
-    expect(idCallOrder.length).toBe(1);
-    expect(idCallOrder[0]).toBe(CHILD.id);
-  });
-
-  it('should not onTouchTap from when dragging beyond threshold', function() {
-    ReactEvent.putListener(
-      CHILD.id,
-      ON_TOUCH_TAP_KEY,
-      recordID.bind(null, CHILD.id)
-    );
-    ReactTestUtils.Simulate.touchStart(
-      CHILD,
-      ReactTestUtils.nativeTouchData(0, 0)
-    );
-    ReactTestUtils.Simulate.touchEnd(
-      CHILD,
-      ReactTestUtils.nativeTouchData(0, tapMoveThreshold + 1)
-    );
-    expect(idCallOrder.length).toBe(0);
-  });
-
-
-  it('should bubble onTouchTap', function() {
-    ReactEvent.putListener(
-      CHILD.id,
-      ON_TOUCH_TAP_KEY,
-      recordID.bind(null, CHILD.id)
-    );
-    ReactEvent.putListener(
-      PARENT.id,
-      ON_TOUCH_TAP_KEY,
-      recordID.bind(null, PARENT.id)
-    );
-    ReactEvent.putListener(
-      GRANDPARENT.id,
-      ON_TOUCH_TAP_KEY,
-      recordID.bind(null, GRANDPARENT.id)
-    );
-    ReactTestUtils.Simulate.touchStart(
-      CHILD,
-      ReactTestUtils.nativeTouchData(0, 0)
-    );
-    ReactTestUtils.Simulate.touchEnd(
-      CHILD,
-      ReactTestUtils.nativeTouchData(0, 0)
-    );
-    expect(idCallOrder.length).toBe(3);
-    expect(idCallOrder[0]).toBe(CHILD.id);
-    expect(idCallOrder[1]).toBe(PARENT.id);
-    expect(idCallOrder[2]).toBe(GRANDPARENT.id);
-  });
-
-});
diff --git a/React/core/__tests__/ReactIdentity-test.js b/React/core/__tests__/ReactIdentity-test.js
deleted file mode 100644
index 3672ada559..0000000000
--- a/React/core/__tests__/ReactIdentity-test.js
+++ /dev/null
@@ -1 +0,0 @@
-throw new Error("nonexistent module required: core/__tests__/ReactIdentity-test");
\ No newline at end of file
diff --git a/React/core/__tests__/ReactInstanceHandles-test.js b/React/core/__tests__/ReactInstanceHandles-test.js
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/React/core/__tests__/ReactMount-test.js b/React/core/__tests__/ReactMount-test.js
deleted file mode 100644
index 7217374ef7..0000000000
--- a/React/core/__tests__/ReactMount-test.js
+++ /dev/null
@@ -1 +0,0 @@
-throw new Error("nonexistent module required: core/__tests__/ReactMount-test");
\ No newline at end of file
diff --git a/React/core/__tests__/ReactMountDestruction-test.js b/React/core/__tests__/ReactMountDestruction-test.js
deleted file mode 100644
index 160896f8d6..0000000000
--- a/React/core/__tests__/ReactMountDestruction-test.js
+++ /dev/null
@@ -1,64 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @jsx React.DOM
- * @emails react-core
- */
-
-"use strict";
-
-var ReactMount = require("../../ReactMount");
-var React = require("../../React");
-var ReactTestUtils = require("../../ReactTestUtils");
-var ReactMount = require("../../ReactMount");
-
-var reactComponentExpect = require("../../reactComponentExpect");
-
-describe('ReactMount', function() {
-  it("should destroy a react root upon request", function() {
-    var mainContainerDiv = document.createElement('div');
-    document.documentElement.appendChild(mainContainerDiv);
-
-    var instanceOne = (
-      React.DOM.div( {className:"firstReactDiv"}, null
-      )
-    );
-    var firstRootDiv = document.createElement('div');
-    mainContainerDiv.appendChild(firstRootDiv);
-    React.renderComponent(instanceOne, firstRootDiv);
-
-    var instanceTwo = (
-      React.DOM.div( {className:"secondReactDiv"}, null
-      )
-    );
-    var secondRootDiv = document.createElement('div');
-    mainContainerDiv.appendChild(secondRootDiv);
-    React.renderComponent(instanceTwo, secondRootDiv);
-
-    // Test that two react roots are rendered in isolation
-    expect(firstRootDiv.getElementsByClassName('firstReactDiv').length)
-      .toBe(1);
-    expect(secondRootDiv.getElementsByClassName('secondReactDiv').length)
-      .toBe(1);
-
-    // Test that after unmounting each, they are no longer in the document.
-    React.unmountAndReleaseReactRootNode(firstRootDiv);
-    expect(firstRootDiv.getElementsByClassName('firstReactDiv').length)
-      .toBe(0);
-    React.unmountAndReleaseReactRootNode(secondRootDiv);
-    expect(secondRootDiv.getElementsByClassName('secondReactDiv').length)
-      .toBe(0);
-  });
-});
diff --git a/React/core/__tests__/ReactMultiChildReconcile-test.js b/React/core/__tests__/ReactMultiChildReconcile-test.js
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/React/core/__tests__/ReactMultiChildText-test.js b/React/core/__tests__/ReactMultiChildText-test.js
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/React/core/__tests__/ReactNativeComponent-test.js b/React/core/__tests__/ReactNativeComponent-test.js
deleted file mode 100644
index 68417914a7..0000000000
--- a/React/core/__tests__/ReactNativeComponent-test.js
+++ /dev/null
@@ -1,242 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @jsx React.DOM
- * @emails react-core
- */
-
-/*jslint evil: true */
-
-"use strict";
-
-describe('ReactNativeComponent', function() {
-
-  describe('updateDOM', function() {
-    var React;
-    var ReactTestUtils;
-    var transaction;
-
-    beforeEach(function() {
-      React = require("../../React");
-      ReactTestUtils = require("../../ReactTestUtils");
-
-      var ReactReconcileTransaction = require("../../ReactReconcileTransaction");
-      transaction = new ReactReconcileTransaction();
-    });
-
-    it("should handle className", function() {
-      var stub = ReactTestUtils.renderIntoDocument(React.DOM.div( {style:{}}, null ));
-
-      stub.receiveProps({ className: 'foo' }, transaction);
-      expect(stub.getDOMNode().className).toEqual('foo');
-      stub.receiveProps({ className: 'bar' }, transaction);
-      expect(stub.getDOMNode().className).toEqual('bar');
-      stub.receiveProps({ className: null }, transaction);
-      expect(stub.getDOMNode().className).toEqual('');
-    });
-
-    it("should gracefully handle various style value types", function() {
-      var stub = ReactTestUtils.renderIntoDocument(React.DOM.div( {style:{}}, null ));
-      var stubStyle = stub.getDOMNode().style;
-
-      // set initial style
-      var setup = { display: 'block', left: '1', top: 2, fontFamily: 'Arial' };
-      stub.receiveProps({ style: setup }, transaction);
-      expect(stubStyle.display).toEqual('block');
-      expect(stubStyle.left).toEqual('1px');
-      expect(stubStyle.fontFamily).toEqual('Arial');
-
-      // reset the style to their default state
-      var reset = { display: '', left: null, top: false, fontFamily: true };
-      stub.receiveProps({ style: reset }, transaction);
-      expect(stubStyle.display).toEqual('');
-      expect(stubStyle.left).toEqual('');
-      expect(stubStyle.top).toEqual('');
-      expect(stubStyle.fontFamily).toEqual('');
-    });
-
-    it("should update styles when mutating style object", function() {
-      var styles = { display: 'none', fontFamily: 'Arial' };
-      var stub = ReactTestUtils.renderIntoDocument(React.DOM.div( {style:styles}, null ));
-
-      var stubStyle = stub.getDOMNode().style;
-      stubStyle.display = styles.display;
-      stubStyle.fontFamily = styles.fontFamily;
-
-      styles.display = 'block';
-
-      stub.receiveProps({ style: styles }, transaction);
-      expect(stubStyle.display).toEqual('block');
-      expect(stubStyle.fontFamily).toEqual('Arial');
-
-      styles.fontFamily = 'Helvetica';
-
-      stub.receiveProps({ style: styles }, transaction);
-      expect(stubStyle.display).toEqual('block');
-      expect(stubStyle.fontFamily).toEqual('Helvetica');
-    });
-
-    it("should update styles if initially null", function() {
-      var styles = null;
-      var stub = ReactTestUtils.renderIntoDocument(React.DOM.div( {style:styles}, null ));
-
-      var stubStyle = stub.getDOMNode().style;
-
-      styles = {display: 'block'};
-
-      stub.receiveProps({ style: styles }, transaction);
-      expect(stubStyle.display).toEqual('block');
-    });
-
-  });
-
-  describe('createOpenTagMarkup', function() {
-    var genMarkup;
-
-    function quoteRegexp(str) {
-      return (str+'').replace(/([.?*+\^$\[\]\\(){}|-])/g, "\\$1");
-    }
-
-    beforeEach(function() {
-      require("../../mock-modules").dumpCache();
-
-      var mixInto = require("../../mixInto");
-      var ReactNativeComponent = require("../../ReactNativeComponent");
-
-      var NodeStub = function(initialProps) {
-        this.props = initialProps || {};
-        this._rootNodeID = 'test';
-      };
-      mixInto(NodeStub, ReactNativeComponent.Mixin);
-
-      genMarkup = function(props) {
-        return (new NodeStub(props))._createOpenTagMarkup();
-      };
-
-      this.addMatchers({
-        toHaveAttribute: function(attr, value) {
-          var expected = '(?:^|\\s)' + attr + '=[\\\'"]';
-          if (typeof value != 'undefined') {
-            expected += quoteRegexp(value) + '[\\\'"]';
-          }
-          return this.actual.match(new RegExp(expected));
-        }
-      });
-    });
-
-    it("should handle className", function() {
-      expect(genMarkup({ className: 'a' })).toHaveAttribute('class', 'a');
-      expect(genMarkup({ className: 'a b' })).toHaveAttribute('class', 'a b');
-      expect(genMarkup({ className: '' })).toHaveAttribute('class', '');
-    });
-  });
-
-  describe('createContentMarkup', function() {
-    var genMarkup;
-
-    function quoteRegexp(str) {
-      return (str+'').replace(/([.?*+\^$\[\]\\(){}|-])/g, "\\$1");
-    }
-
-    beforeEach(function() {
-      require("../../mock-modules").dumpCache();
-
-      var mixInto = require("../../mixInto");
-      var ReactNativeComponent = require("../../ReactNativeComponent");
-      var ReactReconcileTransaction = require("../../ReactReconcileTransaction");
-
-      var NodeStub = function(initialProps) {
-        this.props = initialProps || {};
-        this._rootNodeID = 'test';
-      };
-      mixInto(NodeStub, ReactNativeComponent.Mixin);
-
-      genMarkup = function(props) {
-        var transaction = new ReactReconcileTransaction();
-        return (new NodeStub(props))._createContentMarkup(transaction);
-      };
-
-      this.addMatchers({
-        toHaveInnerhtml: function(html) {
-          var expected = '^' + quoteRegexp(html) + '$';
-          return this.actual.match(new RegExp(expected));
-        }
-      });
-    });
-
-    it("should handle dangerouslySetInnerHTML", function() {
-      var innerHTML = {__html: 'testContent'};
-      expect(
-        genMarkup({ dangerouslySetInnerHTML: innerHTML })
-      ).toHaveInnerhtml('testContent');
-    });
-  });
-
-  describe('mountComponent', function() {
-    var mountComponent;
-
-    beforeEach(function() {
-      require("../../mock-modules").dumpCache();
-
-      var mixInto = require("../../mixInto");
-      var ReactComponent = require("../../ReactComponent");
-      var ReactNativeComponent = require("../../ReactNativeComponent");
-      var ReactReconcileTransaction = require("../../ReactReconcileTransaction");
-
-      var NodeStub = function(initialProps) {
-        ReactComponent.Mixin.construct.call(this, initialProps);
-      };
-      mixInto(NodeStub, ReactNativeComponent.Mixin);
-
-      mountComponent = function(props) {
-        var transaction = new ReactReconcileTransaction();
-        return (new NodeStub(props)).mountComponent('test', transaction);
-      };
-    });
-
-    it("should validate against multiple children props", function() {
-      expect(function() {
-        mountComponent({ content: '', children: '' });
-      }).toThrow(
-        'Invariant Violation: Can only set one of `children`, ' +
-        '`props.content`, or `props.dangerouslySetInnerHTML`.'
-      );
-
-      expect(function() {
-        mountComponent({ content: '', dangerouslySetInnerHTML: '' });
-      }).toThrow(
-        'Invariant Violation: Can only set one of `children`, ' +
-        '`props.content`, or `props.dangerouslySetInnerHTML`.'
-      );
-
-      expect(function() {
-        mountComponent({ children: '', dangerouslySetInnerHTML: '' });
-      }).toThrow(
-        'Invariant Violation: Can only set one of `children`, ' +
-        '`props.content`, or `props.dangerouslySetInnerHTML`.'
-      );
-    });
-
-    it("should validate against invalid styles", function() {
-      expect(function() {
-        mountComponent({ style: 'display: none' });
-      }).toThrow(
-        'Invariant Violation: The `style` prop expects a mapping from style ' +
-        'properties to values, not a string.'
-      );
-    });
-  });
-
-});
diff --git a/React/core/__tests__/ReactProps-test.js b/React/core/__tests__/ReactProps-test.js
deleted file mode 100644
index 323826009a..0000000000
--- a/React/core/__tests__/ReactProps-test.js
+++ /dev/null
@@ -1,142 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @jsx React.DOM
- * @emails react-core
- */
-
-"use strict";
-
-var Props = require("../../ReactProps");
-
-function typeCheck(declaration, value) {
-  var props = {};
-  if (arguments.length > 1) {
-    props.testProp = value;
-  }
-  return declaration.bind(this, props, 'testProp', 'testComponent');
-}
-
-describe('Primitive Types', function() {
-  beforeEach(function() {
-    require("../../mock-modules").dumpCache();
-  });
-
-  it("should throw for invalid strings", function() {
-    expect(typeCheck(Props.string, [])).toThrow(
-      'Invariant Violation: Invalid prop `testProp` of type `array` ' +
-      'supplied to `testComponent`, expected `string`.'
-    );
-    expect(typeCheck(Props.string, false)).toThrow(
-      'Invariant Violation: Invalid prop `testProp` of type `boolean` ' +
-      'supplied to `testComponent`, expected `string`.'
-    );
-    expect(typeCheck(Props.string, 1)).toThrow(
-      'Invariant Violation: Invalid prop `testProp` of type `number` ' +
-      'supplied to `testComponent`, expected `string`.'
-    );
-    expect(typeCheck(Props.string, {})).toThrow(
-      'Invariant Violation: Invalid prop `testProp` of type `object` ' +
-      'supplied to `testComponent`, expected `string`.'
-    );
-  });
-
-  it("should not throw for valid values", function() {
-    expect(typeCheck(Props.array, [])).not.toThrow();
-    expect(typeCheck(Props.bool, false)).not.toThrow();
-    expect(typeCheck(Props.number, 0)).not.toThrow();
-    expect(typeCheck(Props.object, {})).not.toThrow();
-    expect(typeCheck(Props.string, '')).not.toThrow();
-  });
-
-  it("should be implicitly optional and not throw without values", function() {
-    expect(typeCheck(Props.string, null)).not.toThrow();
-    expect(typeCheck(Props.string, undefined)).not.toThrow();
-  });
-
-  it("should throw for missing required values", function() {
-    expect(typeCheck(Props.string.isRequired, null)).toThrow(
-      'Invariant Violation: Required prop `testProp` was not specified in ' +
-      '`testComponent`.'
-    );
-    expect(typeCheck(Props.string.isRequired, undefined)).toThrow(
-      'Invariant Violation: Required prop `testProp` was not specified in ' +
-      '`testComponent`.'
-    );
-  });
-});
-
-describe('Enum Types', function() {
-  beforeEach(function() {
-    require("../../mock-modules").dumpCache();
-  });
-
-  it("should throw for invalid strings", function() {
-    expect(typeCheck(Props.oneOf(['red', 'blue']), true)).toThrow(
-      'Invariant Violation: Invalid prop `testProp` supplied to ' +
-      '`testComponent`, expected one of ["blue","red"].'
-    );
-    expect(typeCheck(Props.oneOf(['red', 'blue']), [])).toThrow(
-      'Invariant Violation: Invalid prop `testProp` supplied to ' +
-      '`testComponent`, expected one of ["blue","red"].'
-    );
-    expect(typeCheck(Props.oneOf(['red', 'blue']), '')).toThrow(
-      'Invariant Violation: Invalid prop `testProp` supplied to ' +
-      '`testComponent`, expected one of ["blue","red"].'
-    );
-  });
-
-  it("should not throw for valid values", function() {
-    expect(typeCheck(Props.oneOf(['red', 'blue']), 'red')).not.toThrow();
-    expect(typeCheck(Props.oneOf(['red', 'blue']), 'blue')).not.toThrow();
-  });
-
-  it("should be implicitly optional and not throw without values", function() {
-    expect(typeCheck(Props.oneOf(['red', 'blue']), null)).not.toThrow();
-    expect(typeCheck(Props.oneOf(['red', 'blue']), undefined)).not.toThrow();
-  });
-});
-
-describe('Instance Types', function() {
-  beforeEach(function() {
-    require("../../mock-modules").dumpCache();
-  });
-
-  it("should throw for invalid instances", function() {
-    function Person() {}
-
-    expect(typeCheck(Props.instanceOf(Person), false)).toThrow(
-      'Invariant Violation: Invalid prop `testProp` supplied to ' +
-      '`testComponent`, expected instance of `Person`.'
-    );
-    expect(typeCheck(Props.instanceOf(Person), {})).toThrow(
-      'Invariant Violation: Invalid prop `testProp` supplied to ' +
-      '`testComponent`, expected instance of `Person`.'
-    );
-    expect(typeCheck(Props.instanceOf(Person), '')).toThrow(
-      'Invariant Violation: Invalid prop `testProp` supplied to ' +
-      '`testComponent`, expected instance of `Person`.'
-    );
-  });
-
-  it("should not throw for valid values", function() {
-    function Person() {}
-    function Engineer() {}
-    Engineer.prototype = new Person();
-
-    expect(typeCheck(Props.instanceOf(Person), new Person())).not.toThrow();
-    expect(typeCheck(Props.instanceOf(Person), new Engineer())).not.toThrow();
-  });
-});
diff --git a/React/core/__tests__/ReactStateSetters-test.js b/React/core/__tests__/ReactStateSetters-test.js
deleted file mode 100644
index 4c9a8a7df3..0000000000
--- a/React/core/__tests__/ReactStateSetters-test.js
+++ /dev/null
@@ -1,162 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @jsx React.DOM
- * @emails react-core
- */
-
-"use strict";
-
-var React = require("../../React");
-var ReactStateSetters = require("../../ReactStateSetters");
-var ReactTestUtils = require("../../ReactTestUtils");
-
-var TestComponent;
-var TestComponentWithMixin;
-
-describe('ReactStateSetters', function() {
-  beforeEach(function() {
-    require("../../mock-modules").dumpCache();
-
-    TestComponent = React.createClass({
-      getInitialState: function() {
-        return {foo: 'foo'};
-      },
-
-      render: function() {
-        return React.DOM.div(null, null );
-      }
-    });
-
-    TestComponentWithMixin = React.createClass({
-      mixins: [ReactStateSetters.Mixin],
-
-      getInitialState: function() {
-        return {foo: 'foo'};
-      },
-
-      render: function() {
-        return React.DOM.div(null, null );
-      }
-    });
-  });
-
-  it('createStateSetter should update state', function() {
-    var instance = TestComponent(null, null );
-    ReactTestUtils.renderIntoDocument(instance);
-    expect(instance.state).toEqual({foo: 'foo'});
-
-    var setter = ReactStateSetters.createStateSetter(
-      instance,
-      function(a, b, c) {
-        return {
-          foo: a + b + c,
-          bar: a * b * c
-        };
-      }
-    );
-    expect(instance.state).toEqual({foo: 'foo'});
-
-    setter(1, 2, 3);
-    expect(instance.state).toEqual({foo: 6, bar: 6});
-
-    setter(10, 11, 12);
-    expect(instance.state).toEqual({foo: 33, bar: 1320});
-  });
-
-  it('createStateKeySetter should update state', function() {
-    var instance = TestComponent(null, null );
-    ReactTestUtils.renderIntoDocument(instance);
-    expect(instance.state).toEqual({foo: 'foo'});
-
-    var setter = ReactStateSetters.createStateKeySetter(instance, 'foo');
-
-    expect(instance.state).toEqual({foo: 'foo'});
-
-    setter('bar');
-    expect(instance.state).toEqual({foo: 'bar'});
-
-    setter('baz');
-    expect(instance.state).toEqual({foo: 'baz'});
-  });
-
-  it('createStateKeySetter is memoized', function() {
-    var instance = TestComponent(null, null );
-    ReactTestUtils.renderIntoDocument(instance);
-    expect(instance.state).toEqual({foo: 'foo'});
-
-    var foo1 = ReactStateSetters.createStateKeySetter(instance, 'foo');
-    var bar1 = ReactStateSetters.createStateKeySetter(instance, 'bar');
-
-    var foo2 = ReactStateSetters.createStateKeySetter(instance, 'foo');
-    var bar2 = ReactStateSetters.createStateKeySetter(instance, 'bar');
-
-    expect(foo2).toBe(foo1);
-    expect(bar2).toBe(bar1);
-  });
-
-  it('createStateSetter should update state from mixin', function() {
-    var instance = TestComponentWithMixin(null, null );
-    ReactTestUtils.renderIntoDocument(instance);
-    expect(instance.state).toEqual({foo: 'foo'});
-
-    var setter = instance.createStateSetter(
-      function(a, b, c) {
-        return {
-          foo: a + b + c,
-          bar: a * b * c
-        };
-      }
-    );
-    expect(instance.state).toEqual({foo: 'foo'});
-
-    setter(1, 2, 3);
-    expect(instance.state).toEqual({foo: 6, bar: 6});
-
-    setter(10, 11, 12);
-    expect(instance.state).toEqual({foo: 33, bar: 1320});
-  });
-
-  it('createStateKeySetter should update state with mixin', function() {
-    var instance = TestComponentWithMixin(null, null );
-    ReactTestUtils.renderIntoDocument(instance);
-    expect(instance.state).toEqual({foo: 'foo'});
-
-    var setter = instance.createStateKeySetter('foo');
-
-    expect(instance.state).toEqual({foo: 'foo'});
-
-    setter('bar');
-    expect(instance.state).toEqual({foo: 'bar'});
-
-    setter('baz');
-    expect(instance.state).toEqual({foo: 'baz'});
-  });
-
-  it('createStateKeySetter is memoized with mixin', function() {
-    var instance = TestComponentWithMixin(null, null );
-    ReactTestUtils.renderIntoDocument(instance);
-    expect(instance.state).toEqual({foo: 'foo'});
-
-    var foo1 = instance.createStateKeySetter('foo');
-    var bar1 = instance.createStateKeySetter('bar');
-
-    var foo2 = instance.createStateKeySetter('foo');
-    var bar2 = instance.createStateKeySetter('bar');
-
-    expect(foo2).toBe(foo1);
-    expect(bar2).toBe(bar1);
-  });
-});
diff --git a/React/core/__tests__/refs-destruction-test.js b/React/core/__tests__/refs-destruction-test.js
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/React/core/__tests__/refs-test.js b/React/core/__tests__/refs-test.js
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/React/createObjectFrom.js b/React/createObjectFrom.js
deleted file mode 100644
index 1a267a63cc..0000000000
--- a/React/createObjectFrom.js
+++ /dev/null
@@ -1,63 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule createObjectFrom
- */
-
-var hasArrayNature = require("./hasArrayNature");
-
-/**
- * Construct an object from an array of keys
- * and optionally specified value or list of values.
- *
- *  >>> createObjectFrom(['a','b','c']);
- *  {a: true, b: true, c: true}
- *
- *  >>> createObjectFrom(['a','b','c'], false);
- *  {a: false, b: false, c: false}
- *
- *  >>> createObjectFrom(['a','b','c'], 'monkey');
- *  {c:'monkey', b:'monkey' c:'monkey'}
- *
- *  >>> createObjectFrom(['a','b','c'], [1,2,3]);
- *  {a: 1, b: 2, c: 3}
- *
- *  >>> createObjectFrom(['women', 'men'], [true, false]);
- *  {women: true, men: false}
- *
- * @param   Array   list of keys
- * @param   mixed   optional value or value array.  defaults true.
- * @returns object
- */
-function createObjectFrom(keys, values /* = true */) {
-  if (true) {
-    if (!hasArrayNature(keys)) {
-      throw new TypeError('Must pass an array of keys.');
-    }
-  }
-
-  var object = {};
-  var is_array = hasArrayNature(values);
-  if (typeof values == 'undefined') {
-    values = true;
-  }
-
-  for (var ii = keys.length; ii--;) {
-    object[keys[ii]] = is_array ? values[ii] : values;
-  }
-  return object;
-}
-
-module.exports = createObjectFrom;
diff --git a/React/cx.js b/React/cx.js
deleted file mode 100644
index 7ca968bfb0..0000000000
--- a/React/cx.js
+++ /dev/null
@@ -1,44 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule cx
- */
-
-/**
- * This function is used to mark string literals representing CSS class names
- * so that they can be transformed statically. This allows for modularization
- * and minification of CSS class names.
- *
- * In static_upstream, this function is actually implemented, but it should
- * eventually be replaced with something more descriptive, and the transform
- * that is used in the main stack should be ported for use elsewhere.
- *
- * @param string|object className to modularize, or an object of key/values.
- *                      In the object case, the values are conditions that
- *                      determine if the className keys should be included.
- * @param [string ...]  Variable list of classNames in the string case.
- * @return string       Renderable space-separated CSS className.
- */
-function cx(classNames) {
-  if (typeof classNames == 'object') {
-    return Object.keys(classNames).map(function(className) {
-      return classNames[className] ? className : '';
-    }).join(' ');
-  } else {
-    return Array.prototype.join.call(arguments, ' ');
-  }
-}
-
-module.exports = cx;
diff --git a/React/dangerousStyleValue.js b/React/dangerousStyleValue.js
deleted file mode 100644
index 182806c336..0000000000
--- a/React/dangerousStyleValue.js
+++ /dev/null
@@ -1,51 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule dangerousStyleValue
- * @typechecks
- */
-
-"use strict";
-
-var CSSProperty = require("./CSSProperty");
-
-/**
- * Convert a value into the proper css writable value. The `styleName` name
- * name should be logical (no hyphens), as specified in `CSSProperty.isNumber`.
- *
- * @param {string} styleName CSS property name such as `topMargin`.
- * @param {*} value CSS property value such as `10px`.
- * @return {string} Normalized style value with dimensions applied.
- */
-function dangerousStyleValue(styleName, value) {
-  // Note that we've removed escapeTextForBrowser() calls here since the
-  // whole string will be escaped when the attribute is injected into
-  // the markup. If you provide unsafe user data here they can inject
-  // arbitrary CSS which may be problematic (I couldn't repro this):
-  // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
-  // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
-  // This is not an XSS hole but instead a potential CSS injection issue
-  // which has lead to a greater discussion about how we're going to
-  // trust URLs moving forward. See #2115901
-  if (value === null || value === false || value === true || value === '') {
-    return '';
-  }
-  if (isNaN(value)) {
-    return !value ? '' : '' + value;
-  }
-  return CSSProperty.isNumber[styleName] ? '' + value : (value + 'px');
-}
-
-module.exports = dangerousStyleValue;
diff --git a/React/dom/__tests__/CSSPropertyOperations-test.js b/React/dom/__tests__/CSSPropertyOperations-test.js
deleted file mode 100644
index 327e366d33..0000000000
--- a/React/dom/__tests__/CSSPropertyOperations-test.js
+++ /dev/null
@@ -1 +0,0 @@
-throw new Error("nonexistent module required: dom/__tests__/CSSPropertyOperations-test");
\ No newline at end of file
diff --git a/React/dom/__tests__/DOMPropertyOperations-test.js b/React/dom/__tests__/DOMPropertyOperations-test.js
deleted file mode 100644
index d803eabc0a..0000000000
--- a/React/dom/__tests__/DOMPropertyOperations-test.js
+++ /dev/null
@@ -1 +0,0 @@
-throw new Error("nonexistent module required: dom/__tests__/DOMPropertyOperations-test");
\ No newline at end of file
diff --git a/React/domUtils/__tests__/CSSPropertyOperations-test.js b/React/domUtils/__tests__/CSSPropertyOperations-test.js
deleted file mode 100644
index 2ea8fb936c..0000000000
--- a/React/domUtils/__tests__/CSSPropertyOperations-test.js
+++ /dev/null
@@ -1,52 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @jsx React.DOM
- * @emails react-core
- */
-
-"use strict";
-
-describe('CSSPropertyOperations', function() {
-  var CSSPropertyOperations;
-
-  beforeEach(function() {
-    require("../../mock-modules").dumpCache();
-    CSSPropertyOperations = require("../../CSSPropertyOperations");
-  });
-
-  it('should create markup for simple styles', function() {
-    expect(CSSPropertyOperations.createMarkupForStyles({
-      backgroundColor: '#3b5998',
-      display: 'none'
-    })).toBe('background-color:#3b5998;display:none;');
-  });
-
-  it('should ignore undefined styles', function() {
-    expect(CSSPropertyOperations.createMarkupForStyles({
-      backgroundColor: undefined,
-      display: 'none'
-    })).toBe('display:none;');
-  });
-
-  it('should automatically append `px` to relevant styles', function() {
-    expect(CSSPropertyOperations.createMarkupForStyles({
-      margin: 16,
-      opacity: 0.5,
-      padding: '4px'
-    })).toBe('margin:16px;opacity:0.5;padding:4px;');
-  });
-
-});
diff --git a/React/domUtils/__tests__/DOMPropertyOperations-test.js b/React/domUtils/__tests__/DOMPropertyOperations-test.js
deleted file mode 100644
index 5b13004b81..0000000000
--- a/React/domUtils/__tests__/DOMPropertyOperations-test.js
+++ /dev/null
@@ -1,129 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @jsx React.DOM
- * @emails react-core
- */
-
-"use strict";
-
-describe('DOMPropertyOperations', function() {
-  var DOMPropertyOperations;
-
-  beforeEach(function() {
-    require("../../mock-modules").dumpCache();
-    DOMPropertyOperations = require("../../DOMPropertyOperations");
-  });
-
-  describe('createMarkupForProperty', function() {
-
-    it('should create markup for simple properties', function() {
-      expect(DOMPropertyOperations.createMarkupForProperty(
-        'name',
-        'simple'
-      )).toBe('name="simple"');
-
-      expect(DOMPropertyOperations.createMarkupForProperty(
-        'name',
-        false
-      )).toBe('name="false"');
-
-      expect(DOMPropertyOperations.createMarkupForProperty(
-        'name',
-        null
-      )).toBe('');
-    });
-
-    it('should create markup for boolean properties', function() {
-      expect(DOMPropertyOperations.createMarkupForProperty(
-        'checked',
-        'simple'
-      )).toBe('checked="simple"');
-
-      expect(DOMPropertyOperations.createMarkupForProperty(
-        'checked',
-        true
-      )).toBe('checked="true"');
-
-      expect(DOMPropertyOperations.createMarkupForProperty(
-        'checked',
-        false
-      )).toBe('');
-    });
-
-    it('should create markup for custom attributes', function() {
-      expect(DOMPropertyOperations.createMarkupForProperty(
-        'aria-label',
-        'simple'
-      )).toBe('aria-label="simple"');
-
-      expect(DOMPropertyOperations.createMarkupForProperty(
-        'aria-label',
-        false
-      )).toBe('aria-label="false"');
-
-      expect(DOMPropertyOperations.createMarkupForProperty(
-        'aria-label',
-        null
-      )).toBe('');
-    });
-
-  });
-
-  describe('setValueForProperty', function() {
-    var stubNode;
-
-    beforeEach(function() {
-      stubNode = document.createElement('div');
-    });
-
-    it('should set values as properties by default', function() {
-      DOMPropertyOperations.setValueForProperty(stubNode, 'title', 'Tip!');
-      expect(stubNode.title).toBe('Tip!');
-    });
-
-    it('should set values as attributes if necessary', function() {
-      DOMPropertyOperations.setValueForProperty(stubNode, 'ajaxify', '#');
-      expect(stubNode.getAttribute('ajaxify')).toBe('#');
-      expect(stubNode.ajaxify).toBeUndefined();
-    });
-
-    it('should remove for falsey boolean properties', function() {
-      DOMPropertyOperations.setValueForProperty(
-        stubNode,
-        'allowFullScreen',
-        false
-      );
-      expect(stubNode.hasAttribute('allowFullScreen')).toBe(false);
-    });
-
-    it('should use mutation method where applicable', function() {
-      DOMPropertyOperations.setValueForProperty(
-        stubNode,
-        'className',
-        'selected'
-      );
-      expect(stubNode.className).toBe('selected');
-
-      DOMPropertyOperations.setValueForProperty(
-        stubNode,
-        'className',
-        null
-      );
-      expect(stubNode.className).toBe('');
-    });
-
-  });
-});
diff --git a/React/emptyFunction.js b/React/emptyFunction.js
deleted file mode 100644
index d1570d08e5..0000000000
--- a/React/emptyFunction.js
+++ /dev/null
@@ -1,50 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule emptyFunction
- */
-
-var copyProperties = require("./copyProperties");
-
-function makeEmptyFunction(arg) {
-  return function() {
-    return arg;
-  };
-}
-
-/**
- * This function accepts and discards inputs; it has no side effects. This is
- * primarily useful idiomatically for overridable function endpoints which
- * always need to be callable, since JS lacks a null-call idiom ala Cocoa.
- */
-function emptyFunction() {}
-
-copyProperties(emptyFunction, {
-  thatReturns: makeEmptyFunction,
-  thatReturnsFalse: makeEmptyFunction(false),
-  thatReturnsTrue: makeEmptyFunction(true),
-  thatReturnsNull: makeEmptyFunction(null),
-  thatReturnsThis: function() { return this; },
-  thatReturnsArgument: function(arg) { return arg; },
-  mustImplement: function(module, property) {
-    return function() {
-      if (true) {
-        throw new Error(module + '.' + property + ' must be implemented!');
-      }
-    };
-  }
-});
-
-module.exports = emptyFunction;
diff --git a/React/environment/__tests__/ReactServerRendering-test.js b/React/environment/__tests__/ReactServerRendering-test.js
deleted file mode 100644
index 328151fab6..0000000000
--- a/React/environment/__tests__/ReactServerRendering-test.js
+++ /dev/null
@@ -1 +0,0 @@
-throw new Error("nonexistent module required: environment/__tests__/ReactServerRendering-test");
\ No newline at end of file
diff --git a/React/erx.js b/React/erx.js
deleted file mode 100644
index 67249777a8..0000000000
--- a/React/erx.js
+++ /dev/null
@@ -1,71 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule erx
- * @typechecks
- * @nostacktrace
- */
-
-var ex = require("./ex");
-
-/**
- * This function reverse transform done by `ex()`.
- *
- * This function only transforms plain text message back to error message with
- * arguments. If the error message is minified by the server, it has to be
- * looked up on the server.
- *
- * This function is designed to be idempotent, so erx(erx(whatever)) will be
- * the same as erx(whatever).
- *
- * @param {string|array<string>} transformedMessage
- */
-
-var erx = function(transformedMessage) {
-  if (typeof transformedMessage !== 'string') {
-    // possibly double `erx`ed and return original value
-    return transformedMessage;
-  }
-
-  var prefixLeft = transformedMessage.indexOf(ex._prefix);
-  var suffixLeft = transformedMessage.lastIndexOf(ex._suffix);
-  if (prefixLeft < 0 || suffixLeft < 0) {
-    // plain error message without any transformation
-    return [transformedMessage];
-  }
-
-  var prefixRight = prefixLeft + ex._prefix.length;
-  var suffixRight = suffixLeft + ex._suffix.length;
-  if (prefixRight >= suffixLeft) {
-    return ['erx slice failure: %s', transformedMessage];
-  }
-
-  var leftSlice = transformedMessage.substring(0, prefixLeft);
-  var rightSlice = transformedMessage.substring(suffixRight);
-  transformedMessage = transformedMessage.substring(prefixRight, suffixLeft);
-
-  var messageWithParams;
-  try {
-    messageWithParams = JSON.parse(transformedMessage);
-    messageWithParams[0] =
-      leftSlice + messageWithParams[0] + rightSlice;
-  } catch(err) {
-    return ['erx parse failure: %s', transformedMessage];
-  }
-
-  return messageWithParams;
-};
-
-module.exports = erx;
diff --git a/React/escapeTextForBrowser.js b/React/escapeTextForBrowser.js
deleted file mode 100644
index 89d3cdb8e4..0000000000
--- a/React/escapeTextForBrowser.js
+++ /dev/null
@@ -1,61 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule escapeTextForBrowser
- */
-
-"use strict";
-
-var throwIf = require("./throwIf");
-
-var ESCAPE_TYPE_ERR;
-
-if (true) {
-  ESCAPE_TYPE_ERR =
-    'The React core has attempted to escape content that is of a ' +
-    'mysterious type (object etc) Escaping only works on numbers and strings';
-}
-
-var ESCAPE_LOOKUP = {
-  "&": "&amp;",
-  ">": "&gt;",
-  "<": "&lt;",
-  "\"": "&quot;",
-  "'": "&#x27;",
-  "/": "&#x2f;"
-};
-
-function escaper(match) {
-  return ESCAPE_LOOKUP[match];
-}
-
-var escapeTextForBrowser = function (text) {
-  var type = typeof text;
-  var invalid = type === 'object';
-  if (true) {
-    throwIf(invalid, ESCAPE_TYPE_ERR);
-  }
-  if (text === '' || invalid) {
-    return '';
-  } else {
-    if (type === 'string') {
-      return text.replace(/[&><"'\/]/g, escaper);
-    } else {
-      return (''+text).replace(/[&><"'\/]/g, escaper);
-    }
-  }
-};
-
-module.exports = escapeTextForBrowser;
diff --git a/React/event/__tests__/EventPluginRegistry-test.js b/React/event/__tests__/EventPluginRegistry-test.js
deleted file mode 100644
index 489991f994..0000000000
--- a/React/event/__tests__/EventPluginRegistry-test.js
+++ /dev/null
@@ -1 +0,0 @@
-throw new Error("nonexistent module required: event/__tests__/EventPluginRegistry-test");
\ No newline at end of file
diff --git a/React/event/synthetic/__tests__/SyntheticEvent-test.js b/React/event/synthetic/__tests__/SyntheticEvent-test.js
deleted file mode 100644
index 550d6997b0..0000000000
--- a/React/event/synthetic/__tests__/SyntheticEvent-test.js
+++ /dev/null
@@ -1 +0,0 @@
-throw new Error("nonexistent module required: event/synthetic/__tests__/SyntheticEvent-test");
\ No newline at end of file
diff --git a/React/event/synthetic/__tests__/SyntheticWheelEvent-test.js b/React/event/synthetic/__tests__/SyntheticWheelEvent-test.js
deleted file mode 100644
index 3500c705db..0000000000
--- a/React/event/synthetic/__tests__/SyntheticWheelEvent-test.js
+++ /dev/null
@@ -1 +0,0 @@
-throw new Error("nonexistent module required: event/synthetic/__tests__/SyntheticWheelEvent-test");
\ No newline at end of file
diff --git a/React/eventPlugins/__tests__/AnalyticsEventPlugin-test.js b/React/eventPlugins/__tests__/AnalyticsEventPlugin-test.js
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/React/eventPlugins/__tests__/ResponderEventPlugin-test.js b/React/eventPlugins/__tests__/ResponderEventPlugin-test.js
deleted file mode 100644
index 2ba03deea5..0000000000
--- a/React/eventPlugins/__tests__/ResponderEventPlugin-test.js
+++ /dev/null
@@ -1,501 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @emails react-core
- */
-
-"use strict";
-
-var CallbackRegistry;
-var EventConstants;
-var EventPropagators;
-var ReactInstanceHandles;
-var ResponderEventPlugin;
-var AbstractEvent;
-
-var GRANDPARENT_ID = '.reactRoot[0]';
-var PARENT_ID = '.reactRoot[0].0';
-var CHILD_ID = '.reactRoot[0].0.0';
-
-var topLevelTypes;
-var responderAbstractEventTypes;
-var spies;
-
-var DUMMY_NATIVE_EVENT = {};
-var DUMMY_RENDERED_TARGET = {};
-
-var onStartShouldSetResponder = function(id, cb, capture) {
-  var registrationNames = responderAbstractEventTypes
-    .startShouldSetResponder
-    .phasedRegistrationNames;
-  CallbackRegistry.putListener(
-    id,
-    capture ? registrationNames.captured : registrationNames.bubbled,
-    cb
-  );
-};
-
-var onScrollShouldSetResponder = function(id, cb, capture) {
-  var registrationNames = responderAbstractEventTypes
-    .scrollShouldSetResponder
-    .phasedRegistrationNames;
-  CallbackRegistry.putListener(
-    id,
-    capture ? registrationNames.captured : registrationNames.bubbled,
-    cb
-  );
-};
-
-var onMoveShouldSetResponder = function(id, cb, capture) {
-  var registrationNames = responderAbstractEventTypes
-    .moveShouldSetResponder
-    .phasedRegistrationNames;
-  CallbackRegistry.putListener(
-    id,
-    capture ? registrationNames.captured : registrationNames.bubbled,
-    cb
-  );
-};
-
-
-var onResponderGrant = function(id, cb) {
-  CallbackRegistry.putListener(
-    id,
-    responderAbstractEventTypes.responderGrant.registrationName,
-    cb
-  );
-};
-
-var extractForTouchStart = function(renderedTargetID) {
-  return ResponderEventPlugin.extractAbstractEvents(
-    topLevelTypes.topTouchStart,
-    DUMMY_NATIVE_EVENT,
-    renderedTargetID,
-    DUMMY_RENDERED_TARGET
-  );
-};
-
-var extractForTouchMove = function(renderedTargetID) {
-  return ResponderEventPlugin.extractAbstractEvents(
-    topLevelTypes.topTouchMove,
-    DUMMY_NATIVE_EVENT,
-    renderedTargetID,
-    DUMMY_RENDERED_TARGET
-  );
-};
-
-var extractForTouchEnd = function(renderedTargetID) {
-  return ResponderEventPlugin.extractAbstractEvents(
-    topLevelTypes.topTouchEnd,
-    DUMMY_NATIVE_EVENT,
-    renderedTargetID,
-    DUMMY_RENDERED_TARGET
-  );
-};
-
-var extractForMouseDown = function(renderedTargetID) {
-  return ResponderEventPlugin.extractAbstractEvents(
-    topLevelTypes.topMouseDown,
-    DUMMY_NATIVE_EVENT,
-    renderedTargetID,
-    DUMMY_RENDERED_TARGET
-  );
-};
-
-var extractForMouseMove = function(renderedTargetID) {
-  return ResponderEventPlugin.extractAbstractEvents(
-    topLevelTypes.topMouseMove,
-    DUMMY_NATIVE_EVENT,
-    renderedTargetID,
-    DUMMY_RENDERED_TARGET
-  );
-};
-
-
-var extractForMouseUp = function(renderedTargetID) {
-  return ResponderEventPlugin.extractAbstractEvents(
-    topLevelTypes.topMouseUp,
-    DUMMY_NATIVE_EVENT,
-    renderedTargetID,
-    DUMMY_RENDERED_TARGET
-  );
-};
-
-var extractForScroll = function(renderedTargetID) {
-  return ResponderEventPlugin.extractAbstractEvents(
-    topLevelTypes.topScroll,
-    DUMMY_NATIVE_EVENT,
-    renderedTargetID,
-    DUMMY_RENDERED_TARGET
-  );
-};
-
-
-var onGrantChild;
-var onGrantParent;
-var onGrantGrandParent;
-
-
-var existsInExtraction = function(extracted, test) {
-  if (Array.isArray(extracted)) {
-    for (var i = 0; i < extracted.length; i++) {
-      if (test(extracted[i])) {
-        return true;
-      }
-    }
-  } else if (extracted) {
-    return test(extracted);
-  }
-  return false;
-};
-
-/**
- * Helper validators.
- */
-function assertGrantEvent(id, extracted) {
-  var test = function(abstractEvent) {
-    return abstractEvent instanceof AbstractEvent &&
-      abstractEvent.type === responderAbstractEventTypes.responderGrant &&
-      abstractEvent.abstractTargetID === id;
-  };
-  expect(ResponderEventPlugin.getResponderID()).toBe(id);
-  expect(existsInExtraction(extracted, test)).toBe(true);
-}
-
-function assertResponderMoveEvent(id, extracted) {
-  var test = function(abstractEvent) {
-    return abstractEvent instanceof AbstractEvent &&
-      abstractEvent.type === responderAbstractEventTypes.responderMove &&
-      abstractEvent.abstractTargetID === id;
-  };
-  expect(ResponderEventPlugin.getResponderID()).toBe(id);
-  expect(existsInExtraction(extracted, test)).toBe(true);
-}
-
-function assertTerminateEvent(id, extracted) {
-  var test = function(abstractEvent) {
-    return abstractEvent instanceof AbstractEvent &&
-      abstractEvent.type === responderAbstractEventTypes.responderTerminate &&
-      abstractEvent.abstractTargetID === id;
-  };
-  expect(ResponderEventPlugin.getResponderID()).not.toBe(id);
-  expect(existsInExtraction(extracted, test)).toBe(true);
-}
-
-function assertRelease(id, extracted) {
-  var test = function(abstractEvent) {
-    return abstractEvent instanceof AbstractEvent &&
-      abstractEvent.type === responderAbstractEventTypes.responderRelease &&
-      abstractEvent.abstractTargetID === id;
-  };
-  expect(ResponderEventPlugin.getResponderID()).toBe(null);
-  expect(existsInExtraction(extracted, test)).toBe(true);
-}
-
-
-function assertNothingExtracted(extracted) {
-  expect(Array.isArray(extracted)).toBe(false);  // No grant events.
-  expect(Array.isArray(extracted)).toBeFalsy();
-}
-
-
-/**
- * TODO:
- * - Test that returning false from `responderTerminationRequest` will never
- *   cause the responder to be lost.
- * - Automate some of this testing by providing config data - generalize.
- */
-
-describe('ResponderEventPlugin', function() {
-  beforeEach(function() {
-    require("../../mock-modules").dumpCache();
-
-    AbstractEvent = require("../../AbstractEvent");
-    CallbackRegistry = require("../../CallbackRegistry");
-    EventConstants = require("../../EventConstants");
-    EventPropagators = require("../../EventPropagators");
-    ReactInstanceHandles = require("../../ReactInstanceHandles");
-    ResponderEventPlugin = require("../../ResponderEventPlugin");
-    EventPropagators.injection.injectInstanceHandle(ReactInstanceHandles);
-
-    // dumpCache, in open-source tests, only resets existing mocks. It does not
-    // reset module-state though -- so we need to do this explicitly in the test
-    // for now. Once that's no longer the case, we can delete this line.
-    CallbackRegistry.__purge();
-
-    topLevelTypes = EventConstants.topLevelTypes;
-    responderAbstractEventTypes = ResponderEventPlugin.abstractEventTypes;
-
-    spies = {
-      onStartShouldSetResponderChild: function() {},
-      onStartShouldSetResponderParent: function() {},
-      onStartShouldSetResponderParentCapture: function() {},
-      onStartShouldSetResponderGrandParent: function() {},
-      onMoveShouldSetResponderParent: function() {},
-      onScrollShouldSetResponderParent: function() {}
-    };
-
-    onGrantChild = function() {};
-    onGrantParent = function() {};
-    onGrantGrandParent = function() {};
-  });
-
-  it('should not auto-set responder on touch start', function() {
-    // Notice we're not registering the startShould* handler.
-    var extracted = extractForTouchStart(CHILD_ID);
-    assertNothingExtracted(extracted);
-    expect(ResponderEventPlugin.getResponderID()).toBe(null);
-  });
-
-  it('should not auto-set responder on mouse down', function() {
-    // Notice we're not registering the startShould* handler.
-    var extracted = extractForMouseDown(CHILD_ID);
-    assertNothingExtracted(extracted);
-    expect(ResponderEventPlugin.getResponderID()).toBe(null);
-    extractForMouseUp(CHILD_ID); // Let up!
-    expect(ResponderEventPlugin.getResponderID()).toBe(null);
-
-    // Register `onMoveShould*` handler.
-    spyOn(spies, 'onMoveShouldSetResponderParent').andReturn(true);
-    onMoveShouldSetResponder(PARENT_ID, spies.onMoveShouldSetResponderParent);
-    onResponderGrant(PARENT_ID, onGrantParent);
-    // Move mouse while not pressing down
-    extracted = extractForMouseMove(CHILD_ID);
-    assertNothingExtracted(extracted);
-    // Not going to call `onMoveShould`* if not touching.
-    expect(spies.onMoveShouldSetResponderParent.callCount).toBe(0);
-    expect(ResponderEventPlugin.getResponderID()).toBe(null);
-
-    // Now try the move extraction again, this time while holding down, and not
-    // letting up.
-    extracted = extractForMouseDown(CHILD_ID);
-    assertNothingExtracted(extracted);
-    expect(ResponderEventPlugin.getResponderID()).toBe(null);
-
-    // Now moving can set the responder, if pressing down, even if there is no
-    // current responder.
-    extracted = extractForMouseMove(CHILD_ID);
-    expect(spies.onMoveShouldSetResponderParent.callCount).toBe(1);
-    expect(ResponderEventPlugin.getResponderID()).toBe(PARENT_ID);
-    assertGrantEvent(PARENT_ID, extracted);
-
-    extractForMouseUp(CHILD_ID);
-    expect(ResponderEventPlugin.getResponderID()).toBe(null);
-  });
-
-  it('should not extract a grant/release event if double start', function() {
-    // Return true - we should become the responder.
-    var extracted;
-    spyOn(spies, 'onStartShouldSetResponderChild').andReturn(true);
-    onStartShouldSetResponder(CHILD_ID, spies.onStartShouldSetResponderChild);
-    onResponderGrant(CHILD_ID, onGrantChild);
-
-    extracted = extractForTouchStart(CHILD_ID);
-    assertGrantEvent(CHILD_ID, extracted);
-    expect(spies.onStartShouldSetResponderChild.callCount).toBe(1);
-
-    // Now we do *not* clear out the touch via a simulated touch end. This mocks
-    // out an environment that likely will never happen, but could in some odd
-    // error state so it's nice to make sure we recover gracefully.
-    // extractForTouchEnd(CHILD_ID); // Clear the responder
-    extracted = extractForTouchStart(CHILD_ID);
-    assertNothingExtracted();
-    expect(spies.onStartShouldSetResponderChild.callCount).toBe(2);
-  });
-
-  it('should bubble/capture responder on start', function() {
-    // Return true - we should become the responder.
-    var extracted;
-    spyOn(spies, 'onStartShouldSetResponderParent').andReturn(true);
-    spyOn(spies, 'onStartShouldSetResponderChild').andReturn(true);
-    onStartShouldSetResponder(CHILD_ID, spies.onStartShouldSetResponderChild);
-    onStartShouldSetResponder(PARENT_ID, spies.onStartShouldSetResponderParent);
-    onResponderGrant(CHILD_ID, onGrantChild);
-    onResponderGrant(PARENT_ID, onGrantParent);
-
-    // Nothing extracted if no responder.
-    extracted = extractForTouchMove(GRANDPARENT_ID);
-    assertNothingExtracted(extracted);
-
-    extracted = extractForTouchStart(CHILD_ID);
-    assertGrantEvent(CHILD_ID, extracted);
-    expect(spies.onStartShouldSetResponderChild.callCount).toBe(1);
-    expect(spies.onStartShouldSetResponderParent.callCount).toBe(0);
-
-    // Even if moving on the grandparent, the child will receive responder moves
-    // (This is even true for mouse interactions - which we should absolutely
-    // test)
-    extracted = extractForTouchMove(GRANDPARENT_ID);
-    assertResponderMoveEvent(CHILD_ID, extracted);
-    extracted = extractForTouchMove(CHILD_ID); // Test move on child node too.
-    assertResponderMoveEvent(CHILD_ID, extracted);
-
-    // Reset the responder - id passed here shouldn't matter:
-    // TODO: Test varying the id here.
-    extracted = extractForTouchEnd(GRANDPARENT_ID); // Clear the responder
-    assertRelease(CHILD_ID, extracted);
-
-    // Now make sure the parent requests responder on capture.
-    spyOn(spies, 'onStartShouldSetResponderParentCapture').andReturn(true);
-    onStartShouldSetResponder(
-      PARENT_ID,
-      spies.onStartShouldSetResponderParent,
-      true    // Capture
-    );
-    onResponderGrant(PARENT_ID, onGrantGrandParent);
-    extracted = extractForTouchStart(PARENT_ID);
-    expect(ResponderEventPlugin.getResponderID()).toBe(PARENT_ID);
-    assertGrantEvent(PARENT_ID, extracted);
-    // Now move on various nodes, ensuring that the responder move is emitted to
-    // the parent node.
-    extracted = extractForTouchMove(GRANDPARENT_ID);
-    assertResponderMoveEvent(PARENT_ID, extracted);
-    extracted = extractForTouchMove(CHILD_ID); // Test move on child node too.
-    assertResponderMoveEvent(PARENT_ID, extracted);
-
-    // Reset the responder - id passed here shouldn't matter:
-    // TODO: Test varying the id here.
-    extracted = extractForTouchEnd(GRANDPARENT_ID); // Clear the responder
-    assertRelease(PARENT_ID, extracted);
-
-  });
-
-  it('should invoke callback to ask if responder is desired', function() {
-    // Return true - we should become the responder.
-    spyOn(spies, 'onStartShouldSetResponderChild').andReturn(true);
-    onStartShouldSetResponder(CHILD_ID, spies.onStartShouldSetResponderChild);
-
-    var extracted = extractForTouchStart(CHILD_ID);
-    assertNothingExtracted(extracted);
-    expect(spies.onStartShouldSetResponderChild.callCount).toBe(1);
-    expect(ResponderEventPlugin.getResponderID()).toBe(CHILD_ID);
-    extractForTouchEnd(CHILD_ID); // Clear the responder
-
-    // Now try returning false - we should not become the responder.
-    spies.onStartShouldSetResponderChild.andReturn(false);
-    onStartShouldSetResponder(CHILD_ID, spies.onStartShouldSetResponderChild);
-    extracted = extractForTouchStart(CHILD_ID);
-    assertNothingExtracted(extracted);
-    expect(spies.onStartShouldSetResponderChild.callCount).toBe(2);
-    expect(ResponderEventPlugin.getResponderID()).toBe(null);
-    extractForTouchEnd(CHILD_ID);
-    expect(ResponderEventPlugin.getResponderID()).toBe(null); // Still null
-
-    // Same thing as before but return true from "shouldSet".
-    spies.onStartShouldSetResponderChild.andReturn(true);
-    onStartShouldSetResponder(CHILD_ID, spies.onStartShouldSetResponderChild);
-    onResponderGrant(CHILD_ID, onGrantChild);
-    extracted = extractForTouchStart(CHILD_ID);
-    expect(spies.onStartShouldSetResponderChild.callCount).toBe(3);
-    assertGrantEvent(CHILD_ID, extracted);
-    extracted = extractForTouchEnd(CHILD_ID); // Clear the responder
-    assertRelease(CHILD_ID, extracted);
-  });
-
-  it('should give up responder to parent on move iff allowed', function() {
-    // Return true - we should become the responder.
-    var extracted;
-    spyOn(spies, 'onStartShouldSetResponderChild').andReturn(true);
-    spyOn(spies, 'onMoveShouldSetResponderParent').andReturn(true);
-    onStartShouldSetResponder(CHILD_ID, spies.onStartShouldSetResponderChild);
-    onMoveShouldSetResponder(PARENT_ID, spies.onMoveShouldSetResponderParent);
-    onResponderGrant(CHILD_ID, onGrantChild);
-    onResponderGrant(PARENT_ID, onGrantParent);
-
-    spies.onStartShouldSetResponderChild.andReturn(true);
-    onStartShouldSetResponder(CHILD_ID, spies.onStartShouldSetResponderChild);
-    extracted = extractForTouchStart(CHILD_ID);
-    expect(spies.onStartShouldSetResponderChild.callCount).toBe(1);
-    expect(spies.onMoveShouldSetResponderParent.callCount).toBe(0); // none yet
-    assertGrantEvent(CHILD_ID, extracted);    // Child is the current responder
-
-    extracted = extractForTouchMove(CHILD_ID);
-    expect(spies.onMoveShouldSetResponderParent.callCount).toBe(1);
-    assertGrantEvent(PARENT_ID, extracted);
-    assertTerminateEvent(CHILD_ID, extracted);
-
-    extracted = extractForTouchEnd(CHILD_ID); // Clear the responder
-    assertRelease(PARENT_ID, extracted);
-  });
-
-  it('should responder move only on direct responder', function() {
-    // Return true - we should become the responder.
-    spyOn(spies, 'onStartShouldSetResponderChild').andReturn(true);
-    onStartShouldSetResponder(CHILD_ID, spies.onStartShouldSetResponderChild);
-
-    var extracted = extractForTouchStart(CHILD_ID);
-    assertNothingExtracted(extracted);
-    expect(spies.onStartShouldSetResponderChild.callCount).toBe(1);
-    expect(ResponderEventPlugin.getResponderID()).toBe(CHILD_ID);
-    extractForTouchEnd(CHILD_ID); // Clear the responder
-    expect(ResponderEventPlugin.getResponderID()).toBe(null);
-
-    // Now try returning false - we should not become the responder.
-    spies.onStartShouldSetResponderChild.andReturn(false);
-    onStartShouldSetResponder(CHILD_ID, spies.onStartShouldSetResponderChild);
-    extracted = extractForTouchStart(CHILD_ID);
-    assertNothingExtracted(extracted);
-    expect(spies.onStartShouldSetResponderChild.callCount).toBe(2);
-    expect(ResponderEventPlugin.getResponderID()).toBe(null);
-    extractForTouchEnd(CHILD_ID); // Clear the responder
-
-    // Same thing as before but return true from "shouldSet".
-    spies.onStartShouldSetResponderChild.andReturn(true);
-    onStartShouldSetResponder(CHILD_ID, spies.onStartShouldSetResponderChild);
-    onResponderGrant(CHILD_ID, onGrantChild);
-    extracted = extractForTouchStart(CHILD_ID);
-    expect(spies.onStartShouldSetResponderChild.callCount).toBe(3);
-    assertGrantEvent(CHILD_ID, extracted);
-    extracted = extractForTouchEnd(CHILD_ID); // Clear the responder
-    assertRelease(CHILD_ID, extracted);
-  });
-
-  it('should give up responder to parent on scroll iff allowed', function() {
-    // Return true - we should become the responder.
-    var extracted;
-    spyOn(spies, 'onStartShouldSetResponderChild').andReturn(true);
-    spyOn(spies, 'onMoveShouldSetResponderParent').andReturn(false);
-    spyOn(spies, 'onScrollShouldSetResponderParent').andReturn(true);
-    onStartShouldSetResponder(CHILD_ID, spies.onStartShouldSetResponderChild);
-    onMoveShouldSetResponder(PARENT_ID, spies.onMoveShouldSetResponderParent);
-    onScrollShouldSetResponder(
-      PARENT_ID,
-      spies.onScrollShouldSetResponderParent
-    );
-    onResponderGrant(CHILD_ID, onGrantChild);
-    onResponderGrant(PARENT_ID, onGrantParent);
-
-    spies.onStartShouldSetResponderChild.andReturn(true);
-    onStartShouldSetResponder(CHILD_ID, spies.onStartShouldSetResponderChild);
-    extracted = extractForTouchStart(CHILD_ID);
-    expect(spies.onStartShouldSetResponderChild.callCount).toBe(1);
-    expect(spies.onMoveShouldSetResponderParent.callCount).toBe(0); // none yet
-    assertGrantEvent(CHILD_ID, extracted);    // Child is the current responder
-
-    extracted = extractForTouchMove(CHILD_ID);
-    expect(spies.onMoveShouldSetResponderParent.callCount).toBe(1);
-    assertNothingExtracted(extracted);
-
-    extracted = extractForScroll(CHILD_ID); // Could have been parent here too.
-    expect(spies.onScrollShouldSetResponderParent.callCount).toBe(1);
-    assertGrantEvent(PARENT_ID, extracted);
-    assertTerminateEvent(CHILD_ID, extracted);
-
-    extracted = extractForTouchEnd(CHILD_ID); // Clear the responder
-    assertRelease(PARENT_ID, extracted);
-  });
-
-
-});
diff --git a/React/ex.js b/React/ex.js
deleted file mode 100644
index a81ea006b5..0000000000
--- a/React/ex.js
+++ /dev/null
@@ -1,49 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ex
- * @typechecks
- * @nostacktrace
- */
-
-/**
- * This function transforms error message with arguments into plain text error
- * message, so that it can be passed to window.onerror without losing anything.
- * It can then be transformed back by `erx()` function.
- *
- * Usage:
- *   throw new Error(ex('Error %s from %s', errorCode, userID));
- *
- * @param {string} errorMessage
- */
-
-var ex = function(errorMessage/*, arg1, arg2, ...*/) {
-  var args = Array.prototype.slice.call(arguments).map(function(arg) {
-    return String(arg);
-  });
-  var expectedLength = errorMessage.split('%s').length - 1;
-
-  if (expectedLength !== args.length - 1) {
-    // something wrong with the formatting string
-    return ex('ex args number mismatch: %s', JSON.stringify(args));
-  }
-
-  return ex._prefix + JSON.stringify(args) + ex._suffix;
-};
-
-ex._prefix = '<![EX[';
-ex._suffix = ']]>';
-
-module.exports = ex;
diff --git a/React/flattenChildren.js b/React/flattenChildren.js
deleted file mode 100644
index b132ec8ba2..0000000000
--- a/React/flattenChildren.js
+++ /dev/null
@@ -1,93 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule flattenChildren
- */
-
-"use strict";
-
-var ReactTextComponent = require("./ReactTextComponent");
-
-var escapeTextForBrowser = require("./escapeTextForBrowser");
-
-var throwIf = require("./throwIf");
-
-/**
- * @polyFill Array.isArray
- */
-
-
-var INVALID_CHILD = 'INVALID_CHILD';
-if (true) {
-  INVALID_CHILD =
-    'You may not pass a child of that type to a React component. It ' +
-    'is a common mistake to try to pass a standard browser DOM element ' +
-    'as a child of a React component.';
-}
-
-/**
- * If there is only a single child, it still needs a name.
- */
-var ONLY_CHILD_NAME = '0';
-
-var flattenChildrenImpl = function(res, children, nameSoFar) {
-  if (Array.isArray(children)) {
-    for (var i = 0; i < children.length; i++) {
-      flattenChildrenImpl(res, children[i], nameSoFar + '[' + i + ']');
-    }
-  } else {
-    var type = typeof children;
-    var isOnlyChild = nameSoFar === '';
-    var storageName = isOnlyChild ? ONLY_CHILD_NAME : nameSoFar;
-    if (children === null || children === undefined || type === 'boolean') {
-      res[storageName] = null;
-    } else if (children.mountComponentIntoNode) {
-      /* We found a component instance */
-      res[storageName] = children;
-    } else {
-      if (type === 'object') {
-        throwIf(children && children.nodeType === 1, INVALID_CHILD);
-        for (var key in children) {
-          if (children.hasOwnProperty(key)) {
-            flattenChildrenImpl(
-              res,
-              children[key],
-              nameSoFar + '{' + escapeTextForBrowser(key) + '}'
-            );
-          }
-        }
-      } else if (type === 'string') {
-        res[storageName] = new ReactTextComponent(children);
-      } else if (type === 'number') {
-        res[storageName] = new ReactTextComponent('' + children);
-      }
-    }
-  }
-};
-
-/**
- * Flattens children that are typically specified as `props.children`.
- * @return {!Object} flattened children keyed by name.
- */
-function flattenChildren(children) {
-  if (children === null || children === undefined) {
-    return children;
-  }
-  var result = {};
-  flattenChildrenImpl(result, children, '');
-  return result;
-}
-
-module.exports = flattenChildren;
diff --git a/React/forEachAccumulated.js b/React/forEachAccumulated.js
deleted file mode 100644
index c756ce17cd..0000000000
--- a/React/forEachAccumulated.js
+++ /dev/null
@@ -1,36 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule forEachAccumulated
- */
-
-"use strict";
-
-/**
- * @param {array} an "accumulation" of items which is either an Array or
- * a single item. Useful when paired with the `accumulate` module. This is a
- * simple utility that allows us to reason about a collection of items, but
- * handling the case when there is exactly one item (and we do not need to
- * allocate an array).
- */
-var forEachAccumulated = function(arr, cb, scope) {
-  if (Array.isArray(arr)) {
-    arr.forEach(cb, scope);
-  } else if (arr) {
-    cb.call(scope, arr);
-  }
-};
-
-module.exports = forEachAccumulated;
diff --git a/React/ge.js b/React/ge.js
deleted file mode 100644
index 76dd2e7423..0000000000
--- a/React/ge.js
+++ /dev/null
@@ -1,76 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ge
- */
-
-/**
- * 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 test
- * for existence yourself in your application code.
- *
- * If your application code depends on the existence of the element, use $
- * instead, which will throw in DEV if the element doesn't exist.
- */
-function ge(arg, root, tag) {
-  return typeof arg != 'string' ? arg :
-    !root ? document.getElementById(arg) :
-    _geFromSubtree(arg, root, tag);
-}
-
-function _geFromSubtree(id, root, tag) {
-  var elem, children, ii;
-
-  if (_getNodeID(root) == id) {
-    return root;
-  } else if (root.getElementsByTagName) {
-    // All Elements implement this, which does an iterative DFS, which is
-    // faster than recursion and doesn't run into stack depth issues.
-    children = root.getElementsByTagName(tag || '*');
-    for (ii = 0; ii < children.length; ii++) {
-      if (_getNodeID(children[ii]) == id) {
-        return children[ii];
-      }
-    }
-  } else {
-    // DocumentFragment does not implement getElementsByTagName, so
-    // recurse over its children. Its children must be Elements, so
-    // each child will use the getElementsByTagName case instead.
-    children = root.childNodes;
-    for (ii = 0; ii < children.length; ii++) {
-      elem = _geFromSubtree(id, children[ii]);
-      if (elem) {
-        return elem;
-      }
-    }
-  }
-
-  return null;
-}
-
-/**
- * Return the ID value for a given node. This allows us to avoid issues
- * with forms that contain inputs with name="id".
- *
- * @return string (null if attribute not set)
- */
-function _getNodeID(node) {
-  // #document and #document-fragment do not have getAttributeNode.
-  var id = node.getAttributeNode && node.getAttributeNode('id');
-  return id ? id.value : null;
-}
-
-module.exports = ge;
diff --git a/React/getDOMNodeID.js b/React/getDOMNodeID.js
deleted file mode 100644
index fbd9cfdcbf..0000000000
--- a/React/getDOMNodeID.js
+++ /dev/null
@@ -1,38 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule getDOMNodeID
- */
-
-"use strict";
-
-/**
- * Accessing "id" or calling getAttribute('id') on a form element can return its
- * control whose name or ID is "id". However, not all DOM nodes support
- * `getAttributeNode` (document - which is not a form) so that is checked first.
- *
- * @param {Element} domNode DOM node element to return ID of.
- * @returns {string} The ID of `domNode`.
- */
-function getDOMNodeID(domNode) {
-  if (domNode.getAttributeNode) {
-    var attributeNode = domNode.getAttributeNode('id');
-    return attributeNode && attributeNode.value || '';
-  } else {
-    return domNode.id || '';
-  }
-}
-
-module.exports = getDOMNodeID;
diff --git a/React/getTextContentAccessor.js b/React/getTextContentAccessor.js
deleted file mode 100644
index 61b38dda63..0000000000
--- a/React/getTextContentAccessor.js
+++ /dev/null
@@ -1,40 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule getTextContentAccessor
- */
-
-"use strict";
-
-var ExecutionEnvironment = require("./ExecutionEnvironment");
-
-var contentKey = null;
-
-/**
- * Gets the key used to access text content on a DOM node.
- *
- * @return {?string} Key used to access text content.
- * @internal
- */
-function getTextContentAccessor() {
-  if (!contentKey && ExecutionEnvironment.canUseDOM) {
-    contentKey = 'innerText' in document.createElement('div') ?
-      'innerText' :
-      'textContent';
-  }
-  return contentKey;
-}
-
-module.exports = getTextContentAccessor;
diff --git a/React/hasArrayNature.js b/React/hasArrayNature.js
deleted file mode 100644
index b145a6de79..0000000000
--- a/React/hasArrayNature.js
+++ /dev/null
@@ -1,52 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule hasArrayNature
- */
-
-/**
- *  Perform a heuristic test to determine if an object is "array-like".
- *
- *    A monk asked Joshu, a Zen master, "Has a dog Buddha nature?"
- *    Joshu replied: "Mu."
- *
- *  This function determines if its argument has "array nature": it returns
- *  true if the argument is an actual array, an `arguments' object, or an
- *  HTMLCollection (e.g. node.childNodes or node.getElementsByTagName()).
- *
- *  @param  obj   An object to test.
- *  @return bool  True if the object is array-like.
- */
-function hasArrayNature(obj) {
-  return (
-    // not null/false
-    !!obj &&
-    // arrays are objects, NodeLists are functions in Safari
-    (typeof obj == 'object' || typeof obj == 'function') &&
-    // quacks like an array
-    ('length' in obj) &&
-    // not window
-    !('setInterval' in obj) &&
-    (
-      // a real array
-      (Object.prototype.toString.call(obj) === "[object Array]" ||
-      // arguments
-      ('callee' in obj) || // HTMLCollection/NodeList
-      'item' in obj)
-    )
-  );
-}
-
-module.exports = hasArrayNature;
diff --git a/React/hyphenate.js b/React/hyphenate.js
deleted file mode 100644
index 0d5d5ba3bb..0000000000
--- a/React/hyphenate.js
+++ /dev/null
@@ -1,35 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule hyphenate
- * @typechecks
- */
-
-var _uppercasePattern = /([A-Z])/g;
-
-/**
- * Hyphenates a camelcased string, for example:
- *
- *   > hyphenate('backgroundColor')
- *   < "background-color"
- *
- * @param {string} string
- * @return {string}
- */
-function hyphenate(string) {
-  return string.replace(_uppercasePattern, '-$1').toLowerCase();
-}
-
-module.exports = hyphenate;
diff --git a/React/insertNodeAt.js b/React/insertNodeAt.js
deleted file mode 100644
index 15b294a884..0000000000
--- a/React/insertNodeAt.js
+++ /dev/null
@@ -1,46 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule insertNodeAt
- */
-
-"use strict";
-
-/**
- * Inserts `node` at a particular child index. Other nodes move to make room.
- * @param {!Element} root The parent root node to insert into.
- * @param {!node} node The node to insert.
- * @param {!number} atIndex The index in `root` that `node` should exist at.
- */
-function insertNodeAt(root, node, atIndex) {
-  var childNodes = root.childNodes;
-  // Remove from parent so that if node is already child of root,
-  // `childNodes[atIndex]` already takes into account the removal.
-  var curAtIndex = root.childNodes[atIndex];
-  if (curAtIndex === node) {
-    return node;
-  }
-  if (node.parentNode) {
-    node.parentNode.removeChild(node);
-  }
-  if (atIndex >= childNodes.length) {
-    root.appendChild(node);
-  } else {
-    root.insertBefore(node, childNodes[atIndex]);
-  }
-  return node;
-}
-
-module.exports = insertNodeAt;
diff --git a/React/invariant.js b/React/invariant.js
deleted file mode 100644
index d0f8ba877d..0000000000
--- a/React/invariant.js
+++ /dev/null
@@ -1,54 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule invariant
- */
-
-/**
- * Use invariant() to assert state which your program assumes to be true.
- *
- * Provide sprintf style format and arguments to provide information about
- * what broke and what you were expecting.
- *
- * The invariant message will be stripped in production, but the invariant
- * will remain to ensure logic does not differ in production.
- */
-
-function invariant(condition) {
-  if (!condition) {
-    throw new Error('Invariant Violation');
-  }
-}
-
-module.exports = invariant;
-
-if (true) {
-  var invariantDev = function(condition, format, a, b, c, d, e, f) {
-    if (format === undefined) {
-      throw new Error('invariant requires an error message argument');
-    }
-
-    if (!condition) {
-      var args = [a, b, c, d, e, f];
-      var argIndex = 0;
-      throw new Error(
-        'Invariant Violation: ' +
-        format.replace(/%s/g, function() { return args[argIndex++]; })
-      );
-    }
-  };
-
-  module.exports = invariantDev;
-}
diff --git a/React/isEventSupported.js b/React/isEventSupported.js
deleted file mode 100644
index 691994b3be..0000000000
--- a/React/isEventSupported.js
+++ /dev/null
@@ -1,62 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule isEventSupported
- */
-
-"use strict";
-
-var ExecutionEnvironment = require("./ExecutionEnvironment");
-
-var testNode;
-if (ExecutionEnvironment.canUseDOM) {
-  testNode = document.createElement('div');
-}
-
-/**
- * Checks if an event is supported in the current execution environment.
- *
- * NOTE: This will not work correctly for non-generic events such as `change`,
- * `reset`, `load`, `error`, and `select`.
- *
- * Borrows from Modernizr.
- *
- * @param {string} eventNameSuffix Event name, e.g. "click".
- * @param {?boolean} capture Check if the capture phase is supported.
- * @return {boolean} True if the event is supported.
- * @internal
- * @license Modernizr 3.0.0pre (Custom Build) | MIT
- */
-function isEventSupported(eventNameSuffix, capture) {
-  if (!testNode || (capture && !testNode.addEventListener)) {
-    return false;
-  }
-  var element = document.createElement('div');
-  var eventName = 'on' + eventNameSuffix;
-  var isSupported = eventName in element;
-
-  if (!isSupported) {
-    element.setAttribute(eventName, '');
-    isSupported = typeof element[eventName] === 'function';
-    if (typeof element[eventName] !== 'undefined') {
-      element[eventName] = undefined;
-    }
-    element.removeAttribute(eventName);
-  }
-  element = null;
-  return isSupported;
-}
-
-module.exports = isEventSupported;
diff --git a/React/joinClasses.js b/React/joinClasses.js
deleted file mode 100644
index af367123d8..0000000000
--- a/React/joinClasses.js
+++ /dev/null
@@ -1,44 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule joinClasses
- * @typechecks
- */
-
-"use strict";
-
-/**
- * Combines multiple className strings into one.
- * http://jsperf.com/joinclasses-args-vs-array
- *
- * @param {...?string} classes
- * @return {string}
- */
-function joinClasses(className/*, ... */) {
-  if (!className) {
-    className = '';
-  }
-  var nextClass;
-  var argLength = arguments.length;
-  if (argLength > 1) {
-    for (var ii = 1; ii < argLength; ii++) {
-      nextClass = arguments[ii];
-      nextClass && (className += ' ' + nextClass);
-    }
-  }
-  return className;
-}
-
-module.exports = joinClasses;
diff --git a/React/keyMirror.js b/React/keyMirror.js
deleted file mode 100644
index 82f163686b..0000000000
--- a/React/keyMirror.js
+++ /dev/null
@@ -1,56 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule keyMirror
- */
-
-"use strict";
-
-var throwIf = require("./throwIf");
-
-var NOT_OBJECT_ERROR = 'NOT_OBJECT_ERROR';
-if (true) {
-  NOT_OBJECT_ERROR = 'keyMirror only works on objects';
-}
-
-/**
- * Utility for constructing enums with keys being equal to the associated
- * values, even when using advanced key crushing. This is useful for debugging,
- * but also for using the values themselves as lookups into the enum.
- * Example:
- * var COLORS = keyMirror({blue: null, red: null});
- * var myColor = COLORS.blue;
- * var isColorValid = !!COLORS[myColor]
- * The last line could not be performed if the values of the generated enum were
- * not equal to their keys.
- * Input:  {key1: val1, key2: val2}
- * Output: {key1: key1, key2: key2}
- */
-var keyMirror = function(obj) {
-  var ret = {};
-  var key;
-
-  throwIf(!(obj instanceof Object) || Array.isArray(obj), NOT_OBJECT_ERROR);
-
-  for (key in obj) {
-    if (!obj.hasOwnProperty(key)) {
-      continue;
-    }
-    ret[key] = key;
-  }
-  return ret;
-};
-
-module.exports = keyMirror;
diff --git a/React/keyOf.js b/React/keyOf.js
deleted file mode 100644
index 5b880e9bbc..0000000000
--- a/React/keyOf.js
+++ /dev/null
@@ -1,41 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule keyOf
- */
-
-/**
- * Allows extraction of a minified key. Let's the build system minify keys
- * without loosing the ability to dynamically use key strings as values
- * themselves. Pass in an object with a single key/val pair and it will return
- * you the string key of that single record. Suppose you want to grab the
- * value for a key 'className' inside of an object. Key/val minification may
- * have aliased that key to be 'xa12'. keyOf({className: null}) will return
- * 'xa12' in that case. Resolve keys you want to use once at startup time, then
- * reuse those resolutions.
- */
-var keyOf = function(oneKeyObj) {
-  var key;
-  for (key in oneKeyObj) {
-    if (!oneKeyObj.hasOwnProperty(key)) {
-      continue;
-    }
-    return key;
-  }
-  return null;
-};
-
-
-module.exports = keyOf;
diff --git a/React/memoizeStringOnly.js b/React/memoizeStringOnly.js
deleted file mode 100644
index a11d026a23..0000000000
--- a/React/memoizeStringOnly.js
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule memoizeStringOnly
- * @typechecks
- */
-
-"use strict";
-
-/**
- * Memoizes the return value of a function that accepts one string argument.
- *
- * @param {function} callback
- * @return {function}
- */
-function memoizeStringOnly(callback) {
-  var cache = {};
-  return function(string) {
-    if (cache.hasOwnProperty(string)) {
-      return cache[string];
-    } else {
-      return cache[string] = callback.call(this, string);
-    }
-  };
-}
-
-module.exports = memoizeStringOnly;
diff --git a/React/merge.js b/React/merge.js
deleted file mode 100644
index 88e15a5ab6..0000000000
--- a/React/merge.js
+++ /dev/null
@@ -1,37 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule merge
- */
-
-"use strict";
-
-var mergeInto = require("./mergeInto");
-
-/**
- * Shallow merges two structures into a return value, without mutating either.
- *
- * @param {?object} one Optional object with properties to merge from.
- * @param {?object} two Optional object with properties to merge from.
- * @return {object} The shallow extension of one by two.
- */
-var merge = function(one, two) {
-  var result = {};
-  mergeInto(result, one);
-  mergeInto(result, two);
-  return result;
-};
-
-module.exports = merge;
diff --git a/React/mergeDeep.js b/React/mergeDeep.js
deleted file mode 100644
index 1b04b96ea7..0000000000
--- a/React/mergeDeep.js
+++ /dev/null
@@ -1,53 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule mergeDeep
- */
-
-"use strict";
-
-var mergeHelpers = require("./mergeHelpers");
-var mergeDeepInto = require("./mergeDeepInto");
-
-var checkArrayStrategy = mergeHelpers.checkArrayStrategy;
-var checkMergeObjectArgs = mergeHelpers.checkMergeObjectArgs;
-var normalizeMergeArg = mergeHelpers.normalizeMergeArg;
-
-/**
- * @see mergeDeepImpl comments.
- *
- * @param {!Object} one returned will be an structural extension of this.
- * @param {!Object} two values from two take precedence over values in one.
- * @param {?Enum=} arrayStrategy One of `arrayStrategies`.
- * @return {!Object} the extension of one by two.
- */
-var mergeDeep = function(oneParam, twoParam, arrayStrategy) {
-  var one = normalizeMergeArg(oneParam);
-  var two = normalizeMergeArg(twoParam);
-  checkMergeObjectArgs(one, two);
-  checkArrayStrategy(arrayStrategy);
-  var newObj = {};
-  // TODO: This is horribly inefficient. Even when some deep object in `one`
-  // will be clobbered by another entity in `two`, we perform a clone of that
-  // entire structure. To make this code more efficient, we'll need to either
-  // enhance `mergeDeepInto` to accept multiple arguments or mirror that code
-  // here.
-  mergeDeepInto(newObj, one, arrayStrategy);
-  mergeDeepInto(newObj, two, arrayStrategy);
-  return newObj;
-};
-
-
-module.exports = mergeDeep;
diff --git a/React/mergeDeepInto.js b/React/mergeDeepInto.js
deleted file mode 100644
index 05b5f5617c..0000000000
--- a/React/mergeDeepInto.js
+++ /dev/null
@@ -1,238 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule mergeDeepInto
- */
-
-"use strict";
-
-var keyMirror = require("./keyMirror");
-var mergeHelpers = require("./mergeHelpers");
-var throwIf = require("./throwIf");
-
-var ArrayStrategies = mergeHelpers.ArrayStrategies;
-var checkArrayStrategy = mergeHelpers.checkArrayStrategy;
-var checkMergeArrayArgs = mergeHelpers.checkMergeArrayArgs;
-var checkMergeLevel = mergeHelpers.checkMergeLevel;
-var checkMergeObjectArgs = mergeHelpers.checkMergeObjectArgs;
-var isTerminal = mergeHelpers.isTerminal;
-var normalizeMergeArg = mergeHelpers.normalizeMergeArg;
-
-var ERRORS = keyMirror({
-  RUN_TIME_ARRAY_MERGE_FAIL: null
-});
-
-if (true) {
-  ERRORS = {
-    RUN_TIME_ARRAY_MERGE_FAIL:
-      "The caller has not supplied an ArrayStrategy. This is supported as " +
-      "long as the data structures being merged do not contain two Arrays " +
-      "that must be merged together, which is exactly what has just " +
-      "happened. Change the call site to supply an Array merge resolver."
-  };
-}
-
-/**
- * Every deep merge function must handle merging in each of the following cases
- * at every level. We may refer to letters below in implementations. For each
- * case listed, the "Result" listed describes the *value* of the result, but
- * does not specify anything about the memory graph of the result. In other
- * words the Results listed below will be the same for `merge` and `mergeInto`
- * but `merge` may have different guarantees about mutation/cloning. In the
- * table, "Object" refers to a non- Array, non-terminal object. One result is
- * undefined and requires that the caller specify the resolution policy (only
- * when trying to merge two arrays).
- *
- * Scenario                     Result
- * --------------------------------------------------------------
- * [A]: (terminal, terminal)    right terminal
- * [B]: (terminal, Array)       right Array
- * [C]: (terminal, Object)      right Object
- * [D]: (terminal, not present) left terminal
- * [E]: (Array, terminal)       right terminal
- * [F]: (Array, Array)          UNDEFINED - MUST SPECIFY POLICY
- * [G]: (Array, Object)         right Object
- * [H]: (Array, not present)    left Array
- * [I]: (Object, terminal)      right terminal
- * [J]: (Object, Array)         right Array
- * [K]: (Object, Object)        merge of left and right Objects
- * [L]: (Object, not present)   left Object
- * [M]: (not present, terminal) right terminal
- * [N]: (not present, Array)    right Array
- * [O]: (not present, Object)   right Object
- *
- * All merge functions are only expected to reason about "own" properties and,
- * any prototypical properties should have no effect on the result. At the first
- * level of recursion in deep merges, we may choose to normalize arguments
- * (convert undefined to empty objects etc.) The above chart does not describe
- * the result of those top level operations which behave specially due to the
- * normalization.
- */
-
-/**
- * Deep merge implementation for non-Array, non-terminal Objects.
- *
- * @param {!Object} one non-Array, non-terminal Object to be mutated deeply.
- * @param {!Object} two non-Array, non-terminal taking precedence over `one`.
- * @param {?Enum=} arrayStrategy one of `arrayStrategies`.
- * @param {!number} level The level of recursion.
- */
-var mergeDeepIntoObjects = function(one, two, arrayStrategy, level) {
-  checkMergeObjectArgs(one, two);
-  checkMergeLevel(level);
-  var twoKeys = two ? Object.keys(two) : [];
-  for (var i = 0; i < twoKeys.length; i++) {
-    var twoKey = twoKeys[i];
-    mergeSingleFieldDeep(one, two, twoKey, arrayStrategy, level);
-  }
-};
-
-/**
- * Deep merge implementation for Arrays.
- *
- * @param {!Array} one Array to deep merge.
- * @param {!Array} two Array to deep merge "into" `one`.
- * @param {?Enum=} arrayStrategy one of `arrayStrategies`.
- * @param {!number} level Level of recursion.
- */
-var mergeDeepIntoArrays = function(one, two, arrayStrategy, level) {
-  checkMergeArrayArgs(one, two);
-  checkMergeLevel(level);
-
-  var maxLen = Math.max(one.length, two.length);
-  for (var i = 0; i < maxLen; i++) {
-    mergeSingleFieldDeep(one, two, i, arrayStrategy, level);
-  }
-};
-
-/**
- * Given two truthy containers `one` and `two`, and a `key`, performs a deep
- * merge on a logical field.
- *
- * @param {!Array|Object} one Container to merge into.
- * @param {!Array|Object} two Container to merge from.
- * @param {!string} key Key of field that should be merged.
- * @param {lEnum=} arrayStrategy One of `arrayStrategies`.
- * @param {!number} level Current level of recursion.
- */
-var mergeSingleFieldDeep = function(one, two, key, arrayStrategy, level) {
-  var twoVal = two[key];
-  var twoValIsPresent = two.hasOwnProperty(key);
-  var twoValIsTerminal = twoValIsPresent && isTerminal(twoVal);
-  var twoValIsArray = twoValIsPresent && Array.isArray(twoVal);
-  var twoValIsProperObject =
-      twoValIsPresent && !twoValIsArray && !twoValIsArray;
-
-  var oneVal = one[key];
-  var oneValIsPresent = one.hasOwnProperty(key);
-  var oneValIsTerminal = oneValIsPresent && isTerminal(oneVal);
-  var oneValIsArray = oneValIsPresent && Array.isArray(oneVal);
-  var oneValIsProperObject =
-    oneValIsPresent && !oneValIsArray && !oneValIsArray;
-
-  if (oneValIsTerminal) {
-    if (twoValIsTerminal) {             // [A]
-      one[key] = twoVal;
-    } else if (twoValIsArray) {         // [B]
-      one[key] = [];
-      mergeDeepIntoArrays(one[key], twoVal, arrayStrategy, level + 1);
-    } else if (twoValIsProperObject) {  // [C]
-      one[key] = {};
-      mergeDeepIntoObjects(one[key], twoVal, arrayStrategy, level + 1);
-    } else if (!twoValIsPresent) {      // [D]
-      one[key] = oneVal;
-    }
-  } else if (oneValIsArray) {
-    if (twoValIsTerminal) {             // [E]
-      one[key] = twoVal;
-    } else if (twoValIsArray) {         // [F]
-      throwIf(
-        !ArrayStrategies[arrayStrategy],
-        ERRORS.RUN_TIME_ARRAY_MERGE_FAIL
-      );
-      // Else: At this point, the only other valid option is `IndexByIndex`
-      if (arrayStrategy === ArrayStrategies.Clobber) {
-        oneVal.length = 0;
-      }
-      mergeDeepIntoArrays(oneVal, twoVal, arrayStrategy, level + 1);
-    } else if (twoValIsProperObject) {  // [G]
-      one[key] = {};
-      mergeDeepIntoObjects(one[key], twoVal, arrayStrategy, level + 1);
-    } else if (!twoValIsPresent) {      // [H]
-      // Leave the left Array alone
-    }
-  } else if (oneValIsProperObject) {
-    if (twoValIsTerminal) {             // [I]
-      one[key] = twoVal;
-    } else if (twoValIsArray) {         // [J]
-      one[key] = [];
-      mergeDeepIntoArrays(one[key], twoVal, arrayStrategy, level + 1);
-    } else if (twoValIsProperObject) {  // [K]
-      mergeDeepIntoObjects(oneVal, twoVal, arrayStrategy, level + 1);
-    } else if (!twoValIsPresent) {      // [L]
-      // Leave the left Object alone
-    }
-  } else if (!oneValIsPresent) {
-    if (twoValIsTerminal) {             // [M]
-      one[key] = twoVal;
-    } else if (twoValIsArray) {         // [N]
-      one[key] = [];
-      mergeDeepIntoArrays(one[key], twoVal, arrayStrategy, level + 1);
-    } else if (twoValIsProperObject) {  // [O]
-      one[key] = {};
-      mergeDeepIntoObjects(one[key], twoVal, arrayStrategy, level + 1);
-    } else if (!twoValIsPresent) {
-      // Could/should never happen
-    }
-  }
-};
-
-
-
-/**
- * Provides same functionality as mergeInto, but merges by mutating the first
- * argument. Will never mutate the second argument.
- *
- * mergeDeepInto provides two guarantees:
- * 1. In the process of mutating one, will not mutate two.
- * 2. Will not cause any nonTerminal memory to be shared between one and two.
- * This means that no further mutations to one will effect two (unless some
- * other part of your application forms shared memory between one and two).
- *
- * mergeDeepInto does not guarantee that it will *preserve* any shared memory
- * between two and one that existed before invocation. After calling
- * mergeDeepInto, there will be less (or equal) amount of shared memory between
- * one and two.
- *
- * Will tolerate a circular structure as the first parameter, but not the
- * second.
- *
- * Requires that first parameter be a non-Array, non-terminal `Object`, and the
- * second argument either be an `Object` or `null/undefined`. Arrays may exist
- * in the depths of either `Object` as long as an `arrayStrategy` is supplied.
- *
- * The third parameter indicates how merging two `Array`s should be performed.
- *
- * @param {!Object} one Object to be mutated deeply.
- * @param {?Object} two Values from two take precedence over values in one.
- * @param {?Enum=} arrayStrategy One of arrayStrategy
- */
-var mergeDeepInto = function(one, twoParam, arrayStrategy) {
-  var two = normalizeMergeArg(twoParam);
-  checkArrayStrategy(arrayStrategy);  // Will be checked twice, for now
-  mergeDeepIntoObjects(one, two, arrayStrategy, 0);
-};
-
-module.exports = mergeDeepInto;
diff --git a/React/mergeHelpers.js b/React/mergeHelpers.js
deleted file mode 100644
index aff2c6c046..0000000000
--- a/React/mergeHelpers.js
+++ /dev/null
@@ -1,162 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule mergeHelpers
- *
- * requiresPolyfills: Array.isArray
- */
-
-"use strict";
-
-var keyMirror = require("./keyMirror");
-var throwIf = require("./throwIf");
-
-/*
- * Maximum number of levels to traverse. Will catch circular structures.
- * @const
- */
-var MAX_MERGE_DEPTH = 36;
-
-var ERRORS = keyMirror({
-  MERGE_ARRAY_FAIL: null,
-  MERGE_CORE_FAILURE: null,
-  MERGE_TYPE_USAGE_FAILURE: null,
-  MERGE_DEEP_MAX_LEVELS: null,
-  MERGE_DEEP_NO_ARR_STRATEGY: null
-});
-
-if (true) {
-  ERRORS = {
-    MERGE_ARRAY_FAIL:
-      'Unsupported type passed to a merge function. You may have passed a ' +
-      'structure that contains an array and the merge function does not know ' +
-      'how to merge arrays. ',
-
-    MERGE_CORE_FAILURE:
-      'Critical assumptions about the merge functions have been violated. ' +
-      'This is the fault of the merge functions themselves, not necessarily ' +
-      'the callers.',
-
-    MERGE_TYPE_USAGE_FAILURE:
-      'Calling merge function with invalid types. You may call merge ' +
-      'functions (non-array non-terminal) OR (null/undefined) arguments. ' +
-      'mergeInto functions have the same requirements but with an added ' +
-      'restriction that the first parameter must not be null/undefined.',
-
-    MERGE_DEEP_MAX_LEVELS:
-      'Maximum deep merge depth exceeded. You may attempting to merge ' +
-      'circular structures in an unsupported way.',
-    MERGE_DEEP_NO_ARR_STRATEGY:
-      'You must provide an array strategy to deep merge functions to ' +
-      'instruct the deep merge how to resolve merging two arrays.'
-  };
-}
-
-/**
- * We won't worry about edge cases like new String('x') or new Boolean(true).
- * Functions are considered terminals, and arrays are not.
- * @param {*} o The item/object/value to test.
- * @return {boolean} true iff the argument is a terminal.
- */
-var isTerminal = function(o) {
-  return typeof o !== 'object' || o === null;
-};
-
-var mergeHelpers = {
-
-  MAX_MERGE_DEPTH: MAX_MERGE_DEPTH,
-
-  isTerminal: isTerminal,
-
-  /**
-   * Converts null/undefined values into empty object.
-   *
-   * @param {?Object=} arg Argument to be normalized (nullable optional)
-   * @return {!Object}
-   */
-  normalizeMergeArg: function(arg) {
-    return arg === undefined || arg === null ? {} : arg;
-  },
-
-  /**
-   * If merging Arrays, a merge strategy *must* be supplied. If not, it is
-   * likely the caller's fault. If this function is ever called with anything
-   * but `one` and `two` being `Array`s, it is the fault of the merge utilities.
-   *
-   * @param {*} one Array to merge into.
-   * @param {*} two Array to merge from.
-   */
-  checkMergeArrayArgs: function(one, two) {
-    throwIf(
-      !Array.isArray(one) || !Array.isArray(two),
-      ERRORS.MERGE_CORE_FAILURE
-    );
-  },
-
-  /**
-   * @param {*} one Object to merge into.
-   * @param {*} two Object to merge from.
-   */
-  checkMergeObjectArgs: function(one, two) {
-    mergeHelpers.checkMergeObjectArg(one);
-    mergeHelpers.checkMergeObjectArg(two);
-  },
-
-  /**
-   * @param {*} arg
-   */
-  checkMergeObjectArg: function(arg) {
-    throwIf(isTerminal(arg) || Array.isArray(arg), ERRORS.MERGE_CORE_FAILURE);
-  },
-
-  /**
-   * Checks that a merge was not given a circular object or an object that had
-   * too great of depth.
-   *
-   * @param {number} Level of recursion to validate against maximum.
-   */
-  checkMergeLevel: function(level) {
-    throwIf(level >= MAX_MERGE_DEPTH, ERRORS.MERGE_DEEP_MAX_LEVELS);
-  },
-
-  /**
-   * Checks that a merge was not given a circular object or an object that had
-   * too great of depth.
-   *
-   * @param {number} Level of recursion to validate against maximum.
-   */
-  checkArrayStrategy: function(strategy) {
-    throwIf(
-      strategy !== undefined && !(strategy in mergeHelpers.ArrayStrategies),
-      ERRORS.MERGE_DEEP_NO_ARR_STRATEGY
-    );
-  },
-
-  /**
-   * Set of possible behaviors of merge algorithms when encountering two Arrays
-   * that must be merged together.
-   * - `clobber`: The left `Array` is ignored.
-   * - `indexByIndex`: The result is achieved by recursively deep merging at
-   *   each index. (not yet supported.)
-   */
-  ArrayStrategies: keyMirror({
-    Clobber: true,
-    IndexByIndex: true
-  }),
-
-  ERRORS: ERRORS
-};
-
-module.exports = mergeHelpers;
diff --git a/React/mergeInto.js b/React/mergeInto.js
deleted file mode 100644
index 68e2093c34..0000000000
--- a/React/mergeInto.js
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule mergeInto
- * @typechecks
- */
-
-"use strict";
-
-var mergeHelpers = require("./mergeHelpers");
-
-var checkMergeObjectArg = mergeHelpers.checkMergeObjectArg;
-
-/**
- * Shallow merges two structures by mutating the first parameter.
- *
- * @param {object} one Object to be merged into.
- * @param {?object} two Optional object with properties to merge from.
- */
-function mergeInto(one, two) {
-  checkMergeObjectArg(one);
-  if (two != null) {
-    checkMergeObjectArg(two);
-    for (var key in two) {
-      if (!two.hasOwnProperty(key)) {
-        continue;
-      }
-      one[key] = two[key];
-    }
-  }
-}
-
-module.exports = mergeInto;
diff --git a/React/mixInto.js b/React/mixInto.js
deleted file mode 100644
index db1a6e3a41..0000000000
--- a/React/mixInto.js
+++ /dev/null
@@ -1,34 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule mixInto
- */
-
-"use strict";
-
-/**
- * Simply copies properties to the prototype.
- */
-var mixInto = function(constructor, methodBag) {
-  var methodName;
-  for (methodName in methodBag) {
-    if (!methodBag.hasOwnProperty(methodName)) {
-      continue;
-    }
-    constructor.prototype[methodName] = methodBag[methodName];
-  }
-};
-
-module.exports = mixInto;
diff --git a/React/mock-modules.js b/React/mock-modules.js
deleted file mode 100644
index fe6354edeb..0000000000
--- a/React/mock-modules.js
+++ /dev/null
@@ -1,33 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule mock-modules
- */
-
-var global = Function("return this")();
-require("./test/mock-timers").installMockTimers(global);
-
-exports.dumpCache = function() {
-    require("./mocks").clear();
-    return exports;
-};
-
-exports.dontMock = function() {
-    return exports;
-};
-
-exports.mock = function() {
-    return exports;
-};
diff --git a/React/mocks.js b/React/mocks.js
deleted file mode 100644
index d0d60b0f39..0000000000
--- a/React/mocks.js
+++ /dev/null
@@ -1,431 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule mocks
- */
-
-function isA(typeName, value) {
-  return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';
-}
-
-function getType(ref) {
-  if (isA('RegExp', ref)) {
-    return 'regexp';
-  }
-
-  if (isA('Array', ref)) {
-    return 'array';
-  }
-
-  if (isA('Function', ref)) {
-    return 'function';
-  }
-
-  if (isA('Object', ref)) {
-    return 'object';
-  }
-
-  // consider number and string fields to be constants that we want to
-  // pick up as they are
-  if (isA('Number', ref) || isA('String', ref)) {
-    return 'constant';
-  }
-
-  return null;
-}
-
-function makeComponent(metadata) {
-  switch (metadata.type) {
-    case 'object':
-      return {};
-
-    case 'array':
-      return [];
-
-    case 'regexp':
-      return new RegExp();
-
-    case 'constant':
-      return metadata.value;
-
-    case 'function':
-      var defaultReturnValue;
-      var specificReturnValues = [];
-      var mockImpl;
-      var isReturnValueLastSet = false;
-      var calls = [];
-      var instances = [];
-      var prototype =
-        (metadata.members && metadata.members.prototype &&
-          metadata.members.prototype.members) || {};
-
-      var f = function() {
-        dirtyMocks.push(f);
-
-        instances.push(this);
-        calls.push(Array.prototype.slice.call(arguments));
-        if (this instanceof arguments.callee) {
-          // This is probably being called as a constructor
-          for (var slot in prototype) {
-            // Copy prototype methods to the instance to make
-            // it easier to interact with mock instance call and
-            // return values
-            if (prototype[slot].type == 'function') {
-              var protoImpl = this[slot];
-              this[slot] = generateFromMetadata(prototype[slot]);
-              this[slot]._protoImpl = protoImpl;
-            }
-          }
-
-          // Run the mock constructor implementation
-          mockImpl && mockImpl.apply(this, arguments);
-          return;
-        }
-
-        var returnValue;
-        // If return value is last set, either specific or default, i.e.
-        // mockReturnValue()/mockDefaultReturnValue() is called and no
-        // mockImplementation() is called after that.
-        // use the set return value.
-        if (isReturnValueLastSet) {
-          returnValue = specificReturnValues.shift();
-          if (returnValue === undefined) {
-            returnValue = defaultReturnValue;
-          }
-        }
-
-        // If mockImplementation() is last set, or specific return values
-        // are used up, use the mock implementation.
-        if (mockImpl && returnValue === undefined) {
-          return mockImpl.apply(this, arguments);
-        }
-
-        // Otherwise use prototype implementation
-        if (returnValue === undefined && arguments.callee._protoImpl) {
-          return arguments.callee._protoImpl.apply(this, arguments);
-        }
-
-        return returnValue;
-      };
-
-      f._isMockFunction = true;
-
-      f.mock = {
-        calls : calls,
-        instances : instances
-      };
-
-      f.mockClear = function() {
-        calls.length = 0;
-        instances.length = 0;
-      };
-
-      f.mockReturnValue = function(value) {
-        // next function call will return this value or default return value
-        isReturnValueLastSet = true;
-        specificReturnValues.push(value);
-        return f;
-      };
-
-      f.mockDefaultReturnValue = function(value) {
-        // next function call will return specified return value or this one
-        isReturnValueLastSet = true;
-        defaultReturnValue = value;
-        return f;
-      };
-
-      f.mockImplementation = function(fn) {
-        // next function call will use mock implementation return value
-        isReturnValueLastSet = false;
-        mockImpl = fn;
-        return f;
-      };
-
-      f.mockReturnThis = function() {
-        return f.mockImplementation(function() {
-          return this;
-        });
-      };
-
-      f._getMockImplementation = function() {
-        return mockImpl;
-      };
-
-      if (metadata.mockImpl) {
-        f.mockImplementation(metadata.mockImpl);
-      }
-
-      return f;
-  }
-
-  throw new Error('Unrecognized type ' + metadata.type);
-}
-
-function generateFromMetadata(_metadata) {
-  var callbacks = [];
-  var refs = {};
-
-  function generateMock(metadata) {
-    var mock = makeComponent(metadata);
-    if (metadata.ref_id != null) {
-      refs[metadata.ref_id] = mock;
-    }
-
-    function getRefCallback(slot, ref) {
-      return function() {
-        mock[slot] = refs[ref];
-      };
-    }
-
-    for (var slot in metadata.members) {
-      var slotMetadata = metadata.members[slot];
-      if (slotMetadata.ref != null) {
-        callbacks.push(getRefCallback(slot, slotMetadata.ref));
-      } else {
-        mock[slot] = generateMock(slotMetadata);
-      }
-    }
-
-    return mock;
-  }
-
-  var mock = generateMock(_metadata);
-  callbacks.forEach(function(setter) {
-    setter();
-  });
-
-  return mock;
-}
-
-
-function _getMetadata(component, _refs) {
-  var refs = _refs || [];
-
-  // This is a potential performance drain, since the whole list is scanned
-  // for every component
-  var ref = refs.indexOf(component);
-  if (ref > -1) {
-    return {ref: ref};
-  }
-
-  var type = getType(component);
-  if (!type) {
-    return null;
-  }
-
-  var metadata = {type : type};
-  if (type == 'constant') {
-    metadata.value = component;
-    return metadata;
-  } else if (type == 'function') {
-    if (component._isMockFunction) {
-      metadata.mockImpl = component._getMockImplementation();
-    }
-  }
-
-  metadata.ref_id = refs.length;
-  refs.push(component);
-
-  var members = null;
-
-  function addMember(slot, data) {
-    if (!data) {
-      return;
-    }
-    if (!members) {
-      members = {};
-    }
-    members[slot] = data;
-  }
-
-  // Leave arrays alone
-  if (type != 'array') {
-    for (var slot in component) {
-      if (slot.charAt(0) == '_' ||
-          (type == 'function' && component._isMockFunction &&
-           slot.match(/^mock/))) {
-        continue;
-      }
-
-      if (component.hasOwnProperty(slot) ||
-          (type == 'object' && component[slot] != Object.prototype[slot])) {
-        addMember(slot, _getMetadata(component[slot], refs));
-      }
-    }
-
-    // If component is native code function, prototype might be undefined
-    if (type == 'function' && component.prototype) {
-      var prototype = _getMetadata(component.prototype, refs);
-      if (prototype && prototype.members) {
-        addMember('prototype', prototype);
-      }
-    }
-  }
-
-  if (members) {
-    metadata.members = members;
-  }
-
-  return metadata;
-}
-
-function removeUnusedRefs(metadata) {
-  function visit(md, f) {
-    f(md);
-    if (md.members) {
-      for (var slot in md.members) {
-        visit(md.members[slot], f);
-      }
-    }
-  }
-
-  var usedRefs = {};
-  visit(metadata, function(md) {
-    if (md.ref != null) {
-      usedRefs[md.ref] = true;
-    }
-  });
-
-  visit(metadata, function(md) {
-    if (!usedRefs[md.ref_id]) {
-      delete md.ref_id;
-    }
-  });
-}
-
-var dirtyMocks = [];
-
-module.exports = {
-  /**
-   * Invokes the .mockClear method of all function mocks that have been
-   * called since the last time clear was called.
-   */
-  clear: function() {
-    var old = dirtyMocks;
-    dirtyMocks = [];
-    old.forEach(function(mock) {
-      mock.mockClear();
-    });
-  },
-
-  /**
-   * Generates a mock based on the given metadata. Mocks treat functions
-   * specially, and all mock functions have additional members, described in the
-   * documentation for getMockFunction in this module.
-   *
-   * One important note: function prototoypes are handled specially by this
-   * mocking framework. For functions with prototypes, when called as a
-   * constructor, the mock will install mocked function members on the instance.
-   * This allows different instances of the same constructor to have different
-   * values for its mocks member and its return values.
-   *
-   * @param metadata Metadata for the mock in the schema returned by the
-   * getMetadata method of this module.
-   *
-   */
-  generateFromMetadata: generateFromMetadata,
-
-  /**
-   * Inspects the argument and returns its schema in the following recursive
-   * format:
-   * {
-   *  type: ...
-   *  members : {}
-   * }
-   *
-   * Where type is one of 'array', 'object', 'function', or 'ref', and members
-   * is an optional dictionary where the keys are member names and the values
-   * are metadata objects. Function prototypes are defined simply by defining
-   * metadata for the member.prototype of the function. The type of a function
-   * prototype should always be "object". For instance, a simple class might be
-   * defined like this:
-   *
-   * {
-   *  type: 'function',
-   *  members: {
-   *    staticMethod: {type: 'function'},
-   *    prototype: {
-   *      type: 'object',
-   *      members: {
-   *        instanceMethod: {type: 'function'}
-   *      }
-   *    }
-   *  }
-   * }
-   *
-   * Metadata may also contain references to other objects defined within the
-   * same metadata object. The metadata for the referent must be marked with
-   * 'ref_id' key and an arbitrary value. The referer must be marked with a
-   * 'ref' key that has the same value as object with ref_id that it refers to.
-   * For instance, this metadata blob:
-   * {
-   *  type: 'object',
-   *  ref_id: 1,
-   *  members: {
-   *    self: {ref: 1}
-   *  }
-   * }
-   *
-   * defines an object with a slot named 'self' that refers back to the object.
-   *
-   * @param component The component for which to retrieve metadata.
-   */
-  getMetadata: function(component) {
-    var metadata = _getMetadata(component);
-    // to make it easier to work with mock metadata, only preserve references
-    // that are actually used
-    removeUnusedRefs(metadata);
-    return metadata;
-  },
-
-  /**
-   * Generates a stand-alone function with members that help drive unit tests or
-   * confirm expectations. Specifically, functions returned by this method have
-   * the following members:
-   *
-   * .mock:
-   * An object with two members, "calls", and "instances", which are both
-   * lists. The items in the "calls" list are the arguments with which the
-   * function was called. The "instances" list stores the value of 'this' for
-   * each call to the function. This is useful for retrieving instances from a
-   * constructor.
-   *
-   * .mockReturnValue(value)
-   * Pushes the given value onto a FIFO queue of return values for the
-   * function.
-   *
-   * .mockDefaultReturnValue(value)
-   * Sets the default return value for the function.
-   *
-   * .mockImplementation(function)
-   * Sets a mock implementation for the function.
-   *
-   * .mockReturnThis()
-   * Syntactic sugar for .mockImplementation(function() {return this;})
-   *
-   * In case both mockImplementation() and
-   * mockReturnValue()/mockDefaultReturnValue() are called. The priority of
-   * which to use is based on what is the last call:
-   * - if the last call is mockRetrunValue() or mockDefaultReturnValue(),
-   *   use the specific return specific return value or default return value.
-   *   If specific return values are used up or no default return value is set,
-   *   fall back to try mockImplementation();
-   * - if the last call is mockImplementation(), run the given implementation
-   *   and return the result.
-   */
-  getMockFunction: function() {
-    return makeComponent({type: 'function'});
-  }
-};
diff --git a/React/objFilter.js b/React/objFilter.js
deleted file mode 100644
index 65ad395119..0000000000
--- a/React/objFilter.js
+++ /dev/null
@@ -1,48 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule objFilter
- */
-
-"use strict";
-
-/**
- * For each key/value pair, invokes callback func and constructs a resulting
- * object which contains each key/value pair which produces a truthy result
- * from invoking the function:
- *
- *   func(value, key, iteration)
- *
- * @param {?object} obj Object to map keys over
- * @param {function} func Invoked for each key/val pair.
- * @param {?*} context
- * @return {?object} Result of filtering or null if obj is falsey
- */
-function objFilter(obj, func, context) {
-  if (!obj) {
-    return null;
-  }
-  var i = 0;
-  var ret = {};
-  for (var key in obj) {
-    if (obj.hasOwnProperty(key) &&
-        func.call(context, obj[key], key, i++)) {
-      ret[key] = obj[key];
-    }
-  }
-  return ret;
-}
-
-module.exports = objFilter;
diff --git a/React/objMap.js b/React/objMap.js
deleted file mode 100644
index b477c9290f..0000000000
--- a/React/objMap.js
+++ /dev/null
@@ -1,47 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule objMap
- */
-
-"use strict";
-
-/**
- * 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 of
- * of invoking the function:
- *
- *   func(value, key, iteration)
- *
- * @param {?object} obj Object to map keys over
- * @param {function} func Invoked for each key/val pair.
- * @param {?*} context
- * @return {?object} Result of mapping or null if obj is falsey
- */
-function objMap(obj, func, context) {
-  if (!obj) {
-    return null;
-  }
-  var i = 0;
-  var ret = {};
-  for (var key in obj) {
-    if (obj.hasOwnProperty(key)) {
-      ret[key] = func.call(context, obj[key], key, i++);
-    }
-  }
-  return ret;
-}
-
-module.exports = objMap;
diff --git a/React/objMapKeyVal.js b/React/objMapKeyVal.js
deleted file mode 100644
index b99e050c49..0000000000
--- a/React/objMapKeyVal.js
+++ /dev/null
@@ -1,47 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule objMapKeyVal
- */
-
-"use strict";
-
-/**
- * Behaves the same as `objMap` but invokes func with the key first, and value
- * second. Use `objMap` unless you need this special case.
- * Invokes func as:
- *
- *   func(key, value, iteration)
- *
- * @param {?object} obj Object to map keys over
- * @param {!function} func Invoked for each key/val pair.
- * @param {?*} context
- * @return {?object} Result of mapping or null if obj is falsey
- */
-function objMapKeyVal(obj, func, context) {
-  if (!obj) {
-    return null;
-  }
-  var i = 0;
-  var ret = {};
-  for (var key in obj) {
-    if (obj.hasOwnProperty(key)) {
-      ret[key] = func.call(context, key, obj[key], i++);
-    }
-  }
-  return ret;
-}
-
-module.exports = objMapKeyVal;
diff --git a/React/reactComponentExpect.js b/React/reactComponentExpect.js
deleted file mode 100644
index f6c6b6b2e0..0000000000
--- a/React/reactComponentExpect.js
+++ /dev/null
@@ -1,190 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule reactComponentExpect
- * @nolint
- */
-
-var ReactComponent = require("./ReactComponent");
-var ReactTestUtils = require("./ReactTestUtils");
-
-var copyProperties = require("./copyProperties");
-
-function reactComponentExpect(instance) {
-  if (instance instanceof reactComponentExpect) {
-    return instance;
-  }
-
-  if (!(this instanceof reactComponentExpect)) {
-    return new reactComponentExpect(instance);
-  }
-
-  this._instance = instance;
-  this.toBeValidReactComponent();
-}
-
-copyProperties(reactComponentExpect.prototype, {
-  // Getters -------------------------------------------------------------------
-
-  /**
-   * @instance: Retrieves the backing instance.
-   */
-  instance: function() {
-    return this._instance;
-  },
-
-  /**
-   * There are two types of components in the world.
-   * - A component created via React.createClass() - Has a single child
-   *   subComponent - the return value from the .render() function. This
-   *   function @subComponent expects that this._instance is component created
-   *   with React.createClass().
-   * - A primitive DOM component - which has many renderedChildren, each of
-   *   which may have a name that is unique with respect to its siblings. This
-   *   method will fail if this._instance is a primitive component.
-   *
-   * TL;DR: An instance may have a subComponent (this._renderedComponent) or
-   * renderedChildren, but never both. Neither will actually show up until you
-   * render the component (simply instantiating is not enough).
-   */
-  expectRenderedChild: function() {
-    this.toBeCompositeComponent();
-    return new reactComponentExpect(this.instance()._renderedComponent);
-  },
-
-  /**
-   * The nth child of a DOMish component instance that is not falsy.
-   */
-  expectRenderedChildAt: function(childIndex) {
-    // Currently only dom components have arrays of children, but that will
-    // change soon.
-    this.toBeDOMComponent();
-    var renderedChildren = this.instance()._renderedChildren || {};
-    var nonEmptyCount = 0;
-    var name;
-    for (name in renderedChildren) {
-      if (!renderedChildren.hasOwnProperty(name)) {
-        continue;
-      }
-      if (renderedChildren[name]) {
-        if (nonEmptyCount === childIndex) {
-          return new reactComponentExpect(renderedChildren[name]);
-        }
-        nonEmptyCount++;
-      }
-    }
-    throw new Error('Child:' + childIndex + ' is not found');
-  },
-
-  toBeDOMComponentWithChildCount: function(n) {
-    this.toBeDOMComponent();
-    expect(this.instance()._renderedChildren).toBeTruthy();
-    var len = Object.keys(this.instance()._renderedChildren).length;
-    expect(len).toBe(n);
-    return this;
-  },
-
-  toBeDOMComponentWithNoChildren: function() {
-    this.toBeDOMComponent();
-    expect(this.instance()._renderedChildren).toBeFalsy();
-    return this;
-  },
-
-  // Matchers ------------------------------------------------------------------
-
-  /**
-   * A component that is created with React.createClass. Just duck typing
-   * here.
-   */
-  toBeCompositeComponent: function() {
-    this.toBeValidReactComponent();
-    expect(ReactTestUtils.isCompositeComponent(this.instance())).toBe(true);
-    return this;
-  },
-
-  toBeCompositeComponentWithType: function(convenienceConstructor) {
-    expect(ReactTestUtils.isCompositeComponentWithType(
-      this.instance(),
-      convenienceConstructor
-    )).toBe(true);
-    return this;
-  },
-
-  toBeTextComponent: function() {
-    expect(ReactTestUtils.isTextComponent(this.instance())).toBe(true);
-    return this;
-  },
-
-  /**
-   * Falsy values are valid components - the vanished component that is.
-   */
-  toBeValidReactComponent: function() {
-    expect(ReactComponent.isValidComponent(this.instance())).toBe(true);
-    return this;
-  },
-
-  toBePresent: function() {
-    expect(this.instance()).toBeTruthy();
-    return this;
-  },
-
-  /**
-   * A terminal type of component representing some virtual dom node. Just duck
-   * typing here.
-   */
-  toBeDOMComponent: function() {
-    expect(ReactTestUtils.isDOMComponent(this.instance())).toBe(true);
-    return this;
-  },
-
-  toBeDOMComponentWithTag: function(tag) {
-    this.toBeDOMComponent();
-    expect(this.instance().tagName).toBe(tag.toUpperCase());
-    return this;
-  },
-
-  /**
-   * Check that internal state values are equal to a state of expected values.
-   */
-  scalarStateEqual: function(stateNameToExpectedValue) {
-    expect(this.instance()).toBeTruthy();
-    for (var stateName in stateNameToExpectedValue) {
-      if (!stateNameToExpectedValue.hasOwnProperty(stateName)) {
-        continue;
-      }
-      expect(this.instance().state[stateName])
-        .toEqual(stateNameToExpectedValue[stateName]);
-    }
-    return this;
-  },
-
-  /**
-   * Check a set of props are equal to a set of expected values - only works
-   * with scalars.
-   */
-  scalarPropsEqual: function(propNameToExpectedValue) {
-    expect(this.instance()).toBeTruthy();
-    for (var propName in propNameToExpectedValue) {
-      if (!propNameToExpectedValue.hasOwnProperty(propName)) {
-        continue;
-      }
-      expect(this.instance().props[propName])
-        .toEqual(propNameToExpectedValue[propName]);
-    }
-    return this;
-  }
-});
-
-module.exports = reactComponentExpect;
diff --git a/React/test/all.js b/React/test/all.js
deleted file mode 100644
index 4f2da68636..0000000000
--- a/React/test/all.js
+++ /dev/null
@@ -1,57 +0,0 @@
-// This file exists both to give a single entry point for all the utility
-// modules in src/test and to specify an ordering on those modules, since
-// some still have implicit dependencies on others.
-
-var Ap = Array.prototype;
-var slice = Ap.slice;
-var Fp = Function.prototype;
-
-if (!Fp.bind) {
-  // PhantomJS doesn't support Function.prototype.bind natively, so
-  // polyfill it whenever this module is required.
-  Fp.bind = function(context) {
-    var func = this;
-    var args = slice.call(arguments, 1);
-    var bound;
-
-    if (func.prototype) {
-      if (args.length > 0) {
-        bound = function() {
-          return func.apply(
-            !(this instanceof func) && context || this,
-            args.concat(slice.call(arguments))
-          );
-        };
-      } else {
-        bound = function() {
-          return func.apply(
-            !(this instanceof func) && context || this,
-            arguments
-          );
-        };
-      }
-
-      bound.prototype = Object.create(func.prototype);
-
-    } else if (args.length > 0) {
-      bound = function() {
-        return func.apply(
-          context || this,
-          args.concat(slice.call(arguments))
-        );
-      };
-    } else {
-      bound = function() {
-        return func.apply(context || this, arguments);
-      };
-    }
-
-    return bound;
-  };
-}
-
-require("../ReactTestUtils");
-require("../reactComponentExpect");
-require("../mocks");
-require("../mock-modules");
-require("./mock-timers");
diff --git a/React/test/mock-timers.js b/React/test/mock-timers.js
deleted file mode 100644
index 1abae9cf1c..0000000000
--- a/React/test/mock-timers.js
+++ /dev/null
@@ -1,226 +0,0 @@
-var mocks = require("../mocks");
-
-var timers = {};
-// Keep a fake timestamp
-// move on the time when runTimersToTime() is called
-var now = 0;
-
-// add a timer of type either 'timeout' or 'interval'
-function _setTimer(type, callback, delay) {
-  var token = null;
-  do {
-    token = Math.floor(Math.random() * 4294967296) + 1;
-  } while (timers[token]);
-  timers[token] = {
-    type: type,
-    callback: callback,
-    // Add some random msecs to the delay to mimic code execution time.
-    time: now + delay + Math.floor(Math.random() * 5),
-    interval: (type == 'interval' ? delay : 0)
-  };
-  return token;
-}
-
-// clear a timer of type either 'timeout' or 'interval'
-function _clearTimer(type, token) {
-  if (timers[token] && timers[token].type == type) {
-    delete timers[token];
-  }
-}
-
-function _setTimeout(callback, delay) {
-  return _setTimer('timeout', callback, delay);
-}
-
-function _setInterval(callback, delay) {
-  return _setTimer('interval', callback, delay);
-}
-
-function _clearTimeout(token) {
-  _clearTimer('timeout', token);
-}
-
-function _clearInterval(token) {
-  _clearTimer('interval', token);
-}
-
-// Run timer of given token
-function _runTimer(token) {
-  // Skip non-existing token
-  if (timers[token]) {
-    if (timers[token].type == 'timeout') {
-      // for 'timeout', run callback and delete the timer
-      var callback = timers[token].callback;
-      delete timers[token];
-      callback();
-    } else if (timers[token].type == 'interval') {
-      // for 'interval', run callback and set the next invoke time
-      // Add some random msecs to the delay to mimic code execution time.
-      timers[token].time =
-        now + timers[token].interval + Math.floor(Math.random() * 5);
-      timers[token].callback();
-    }
-  }
-}
-
-function _runTimersOnce() {
-  // Invoke all timers once regardsless of the delay
-  for (var token in timers) {
-    _runTimer(token);
-  }
-}
-
-function _runTimersToTime(delay) {
-  var toRunToken = _getNextTimerToken();
-  if (!toRunToken) {
-    return;
-  }
-
-  var minTime = timers[toRunToken].time;
-  if (now + delay < minTime) {
-    // Termination when there's no more timers to invoke
-    now += delay;
-  } else {
-    // Recursively invoke the next to-run timer
-    delay -= (minTime - now);
-    now = minTime;
-    _runTimer(toRunToken);
-    _runTimersToTime(delay);
-  }
-}
-
-function _runTimersRepeatedly() {
-  // Only run a generous 1000 timers and then bail, since we may have entered
-  // a loop if we have more than that.
-  var max_timers = 1000;
-
-  var token;
-  for (var ii = 0; ii < max_timers; ii++) {
-    token = _getNextTimerToken();
-
-    if (!token) {
-      break;
-    }
-
-    _runTimer(token);
-  }
-
-  if (ii === max_timers) {
-    throw new Error("More timers still exist after " + max_timers + " timers!");
-  }
-}
-
-function _clearTimers() {
-  for (var token in timers) {
-    delete timers[token];
-  }
-}
-
-function _getNextTimerToken() {
-  var nextTimerToken = null;
-  var minTime = 31536000000; // One year
-  // Find the next to invoke timer
-  for (var token in timers) {
-    if (timers[token].time < minTime) {
-      nextTimerToken = token;
-      minTime = timers[token].time;
-    }
-  }
-  return nextTimerToken;
-}
-
-var mockTimers = {
-  setTimeout: _setTimeout,
-  clearTimeout: _clearTimeout,
-  setInterval: _setInterval,
-  clearInterval: _clearInterval,
-
-  /**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
-   * Iteratively run callbacks in time order during the time from now to
-   * now + delay.
-   * If one callback register another timer which should be run during now to
-   * now + delay, the new timer will also be run in the right order.
-   *
-   * @param delay
-   */
-  runTimersToTime: _runTimersToTime,
-
-  /**
-   * Run all registered timer once. Newly registered timers will not be run.
-   */
-  runTimersOnce: _runTimersOnce,
-
-  /**
-   * Iteratively run callbacks until there are no timers left to call. Will
-   * stop after a maximum number of iterations to avoid infinite loop.
-   *
-   * @param maximum iterations (optional)
-   */
-  runTimersRepeatedly: _runTimersRepeatedly,
-
-  /**
-   * Clear all timers
-   */
-  clearTimers: _clearTimers,
-
-  /**
-   * Get the number of remaining timers
-   */
-  getTimersCount: function() {
-    return Object.keys(timers).length;
-  }
-};
-
-module.exports.installMockTimers = function(window) {
-  window._originalTimeouts = {
-    setTimeout: window.setTimeout,
-    clearTimeout: window.clearTimeout,
-    setInterval: window.setInterval,
-    clearInterval: window.clearInterval
-  };
-  window.setTimeout =
-    mocks.getMockFunction().mockImplementation(mockTimers.setTimeout);
-  window.clearTimeout =
-    mocks.getMockFunction().mockImplementation(mockTimers.clearTimeout);
-  window.setInterval =
-    mocks.getMockFunction().mockImplementation(mockTimers.setInterval);
-  window.clearInterval =
-    mocks.getMockFunction().mockImplementation(mockTimers.clearInterval);
-  window.mockRunTimersOnce =
-    mocks.getMockFunction().mockImplementation(mockTimers.runTimersOnce);
-  window.mockRunTimersToTime =
-    mocks.getMockFunction().mockImplementation(mockTimers.runTimersToTime);
-  window.mockRunTimersRepeatedly =
-    mocks.getMockFunction().mockImplementation(mockTimers.runTimersRepeatedly);
-  window.mockClearTimers =
-    mocks.getMockFunction().mockImplementation(mockTimers.clearTimers);
-  window.mockGetTimersCount =
-    mocks.getMockFunction().mockImplementation(mockTimers.getTimersCount);
-};
-
-module.exports.uninstallMockTimers = function(window) {
-  window.setTimeout = window._originalTimeouts.setTimeout;
-  window.clearTimeout = window._originalTimeouts.clearTimeout;
-  window.setInterval = window._originalTimeouts.setInterval;
-  window.clearInterval = window._originalTimeouts.clearInterval;
-  window._originalTimeouts = undefined;
-  window.mockRunTimersOnce = undefined;
-  window.mockRunTimersToTime = undefined;
-  window.mockRunTimersRepeatedly = undefined;
-  window.mockClearTimers = undefined;
-  window.mockGetTimersCount = undefined;
-};
diff --git a/React/throwIf.js b/React/throwIf.js
deleted file mode 100644
index fc2decca07..0000000000
--- a/React/throwIf.js
+++ /dev/null
@@ -1,27 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule throwIf
- */
-
-"use strict";
-
-var throwIf = function(condition, err) {
-  if (condition) {
-    throw new Error(err);
-  }
-};
-
-module.exports = throwIf;
diff --git a/React/utils/__tests__/ImmutableObject-test.js b/React/utils/__tests__/ImmutableObject-test.js
deleted file mode 100644
index f2e35bf070..0000000000
--- a/React/utils/__tests__/ImmutableObject-test.js
+++ /dev/null
@@ -1,293 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @emails react-core
- */
-
-"use strict";
-
-require("../../mock-modules")
-    .dontMock('ImmutableObject');
-
-var ImmutableObject;
-
-var expectSeriallyEqual = function(one, two) {
-};
-
-/**
- * To perform performance testing of using `ImmutableObject` vs. not using
- * `ImmutableObject`, such testing must be done with __DEV__ set to false.
- */
-describe('ImmutableObject', function() {
-  var message;
-  beforeEach(function() {
-    require("../../mock-modules").dumpCache();
-    ImmutableObject = require("../../ImmutableObject");
-    this.addMatchers({
-      /**
-       * Equivalent with respect to serialization. Must stringify because
-       * constructors are different and other comparison methods will not
-       * consider them structurally equal. Probably not useful for use outside
-       * of this test module.
-       */
-      toBeSeriallyEqualTo: function(expected) {
-        var actual = this.actual;
-        var notText = this.isNot ? " not" : "";
-        this.message = function () {
-          return "Expected " + JSON.stringify(actual) + notText +
-              " to be serially equal to " + JSON.stringify(expected);
-        };
-
-        return JSON.stringify(actual) === JSON.stringify(expected);
-      }
-    });
-  });
-
-  /**
-   * We are in __DEV__ by default.
-   */
-  var testDev = function(message, testFunc) {
-    it(message, testFunc);
-  };
-
-  var testProd = function(message, testFunc) {
-    // Temporarily enter production mode
-    window.true = false;
-    it(message, testFunc);
-    window.true = true;
-  };
-
-  var testDevAndProd = function(message, testFunc) {
-    testDev(message + ':DEV', testFunc);
-    testProd(message + ':PROD', testFunc);
-  };
-
-  testDev('should be running in DEV', function() {
-    expect(window.true).toBe(true);
-  });
-
-  testDev('should require initial map to be an object', function() {
-    expect(function() {
-      new ImmutableObject([1,2,3]);
-    }).toThrow();
-
-    expect(function() {
-      new ImmutableObject('asdf');
-    }).toThrow();
-
-    expect(function() {
-      new ImmutableObject({oldField: 'asdf', fieldTwo: null});
-    }).not.toThrow();
-  });
-
-  testDevAndProd('should not throw when not mutating directly', function() {
-    var io = new ImmutableObject({oldField: 'asdf'});
-    expect(function() {
-      ImmutableObject.set(io, {newField: null}); // not a mutation!
-    }).not.toThrow();
-  });
-
-  testDev('should prevent shallow field addition when strict', function() {
-    if (window.callPhantom) return;
-    expect(function() {
-      var io = new ImmutableObject({oldField: 'asdf'});
-      io.newField = 'this will not work';
-    }).toThrow();
-  });
-
-  testDev('should prevent shallow field mutation when strict', function() {
-    if (window.callPhantom) return;
-    expect(function() {
-      var io = new ImmutableObject({oldField: 'asdf'});
-      io.oldField = 'this will not work!';
-    }).toThrow();
-  });
-
-  testDev('should prevent deep field addition when strict', function() {
-    if (window.callPhantom) return;
-    expect(function() {
-      var io =
-        new ImmutableObject({shallowField: {deepField: {oldField: null}}});
-      io.shallowField.deepField.oldField = 'this will not work!';
-    }).toThrow();
-  });
-
-  testDev('should prevent deep field mutation when strict', function() {
-    if (window.callPhantom) return;
-    expect(function() {
-      var io =
-        new ImmutableObject({shallowField: {deepField: {oldField: null}}});
-      io.shallowField.deepField.newField = 'this will not work!';
-    }).toThrow();
-  });
-
-  testDevAndProd(
-    'should create object with same structure when set with {}',
-    function() {
-      var beforeIO =
-        new ImmutableObject({shallowField: {deepField: {oldField: null}}});
-      var afterIO = ImmutableObject.set(beforeIO, {});
-      expect(afterIO).toBeSeriallyEqualTo(beforeIO);
-      expect(afterIO).not.toBe(beforeIO);
-    }
-  );
-
-  testDevAndProd(
-    'should create distinct object with shallow field insertion',
-    function() {
-      var beforeStructure = {
-        oldShallowField: {
-          deepField: {
-            oldField: null
-          }
-        }
-      };
-
-      var delta = {
-        newShallowField: 'newShallowFieldHere'
-      };
-
-      var expectedAfterStructure = {
-        oldShallowField: {
-          deepField: {
-            oldField: null
-          }
-        },
-        newShallowField: 'newShallowFieldHere'
-      };
-
-      var beforeIO = new ImmutableObject(beforeStructure);
-      var afterIO = ImmutableObject.set(beforeIO, delta);
-      expect(afterIO).toBeSeriallyEqualTo(expectedAfterStructure);
-      expect(afterIO).not.toBe(beforeIO);
-    }
-  );
-
-  testDevAndProd(
-    'should create distinct object with shallow field mutation',
-      function() {
-      var beforeStructure = {
-        oldShallowField: {
-          deepField: {
-            oldField: null
-          }
-        }
-      };
-
-      var delta = {
-        oldShallowField: 'this will clobber the old field'
-      };
-
-      var expectedAfterStructure = {
-        oldShallowField: 'this will clobber the old field'
-      };
-
-      var beforeIO = new ImmutableObject(beforeStructure);
-      var afterIO = ImmutableObject.set(beforeIO, delta);
-      expect(afterIO).toBeSeriallyEqualTo(expectedAfterStructure);
-      expect(afterIO).not.toBe(beforeIO);
-    }
-  );
-
-  message = 'should create distinct object with deep field insertion';
-  testDevAndProd(message, function() {
-    var beforeStructure = {
-      oldShallowField: {
-        deepField: {
-          oldField: null
-        }
-      }
-    };
-
-    var delta = {
-      oldShallowField: {newDeepField: 'hello'}
-    };
-
-    // ImmutableObject does not yet support deep merging with
-    // ImmutableObject.set().
-    var expectedAfterStructure = {
-      oldShallowField: {newDeepField: 'hello'}
-    };
-
-    var beforeIO = new ImmutableObject(beforeStructure);
-    var afterIO = ImmutableObject.set(beforeIO, delta);
-    expect(afterIO).toBeSeriallyEqualTo(expectedAfterStructure);
-    expect(afterIO).not.toBe(beforeIO);
-  });
-
-  message =
-    'should tolerate arrays at deeper levels and prevent mutation on them';
-  testDevAndProd(message, function() {
-    if (window.callPhantom) {
-      // PhantomJS has a bug with Object.freeze and Arrays.
-      // https://github.com/ariya/phantomjs/issues/10817
-      return;
-    }
-    var beforeStructure = {
-      shallowField: [1,'second field',3]
-    };
-    var io = new ImmutableObject(beforeStructure);
-    expect(function() {
-      io.newField = 'nope!';
-    }).toThrow();
-    expect(function() {
-      io.shallowField[0] = 'nope!';
-    }).toThrow();
-    expect(io.shallowField[1]).toEqual('second field');
-  });
-
-  message = 'should provide a setField interface as sugar for set()';
-  testDevAndProd(message, function() {
-    var beforeIO = new ImmutableObject({initialField: null});
-    var afterIO =
-      ImmutableObject.setField(beforeIO, 'anotherField', 'anotherValue');
-    expect(afterIO).toBeSeriallyEqualTo({
-      initialField: null,
-      anotherField: 'anotherValue'
-    });
-    expect(afterIO).not.toBe(beforeIO);
-  });
-
-  message = 'should recursively create distinct objects when deep copying';
-  testDevAndProd(message, function() {
-    var beforeIO = new ImmutableObject({
-      a: {b: 'b', c: {}, d: 'd', e: new ImmutableObject({f: 'f'}) }
-    });
-    var afterIO = ImmutableObject.setDeep(beforeIO, {
-      a: {b: {}, c: 'C', e: {f: 'F', g: 'G'}, h: 'H'}
-    });
-    expect(afterIO).toBeSeriallyEqualTo({
-      a: {b: {}, c: 'C', d: 'd', e: {f: 'F', g: 'G'}, h: 'H'}
-    })
-    expect(afterIO).not.toBe(beforeIO);
-    expect(afterIO.a).not.toBe(beforeIO.a);
-    expect(afterIO.a.e).not.toBe(beforeIO.a.e);
-  });
-
-  testDevAndProd('should deep copy member immutability', function() {
-    var beforeIO = new ImmutableObject({
-      a: {b: new ImmutableObject({c: 'c'}), e: {f: 'f'}}
-    });
-    var afterIO = ImmutableObject.setDeep(beforeIO, {
-      a: {b: {d: 'D'}, e: new ImmutableObject({g: 'G'})}
-    });
-    expect(afterIO).toBeSeriallyEqualTo({
-      a: {b: {c: 'c', d: 'D'}, e: {f: 'f', g: 'G'}}
-    });
-    expect(afterIO instanceof ImmutableObject).toBe(true);
-    expect(afterIO.a.b instanceof ImmutableObject).toBe(true);
-    expect(afterIO.a.e instanceof ImmutableObject).toBe(true);
-  });
-});
diff --git a/React/utils/__tests__/OrderedMap-test.js b/React/utils/__tests__/OrderedMap-test.js
deleted file mode 100644
index cf312186ed..0000000000
--- a/React/utils/__tests__/OrderedMap-test.js
+++ /dev/null
@@ -1,944 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @emails react-core
- */
-
-"use strict";
-
-var OrderedMap;
-
-/**
- * Shared, reusable objects.
- */
-var hasEmptyStringKey = {
-  'thisKeyIsFine': {data: []},
-  '': {thisShouldCauseAFailure: []},
-  'thisKeyIsAlsoFine': {data: []}
-};
-
-/**
- * Used as map/forEach callback.
- */
-var duplicate = function(itm, key, count) {
-  return {
-    uniqueID: itm.uniqueID,
-    val: itm.val + key + count + this.justToTestScope
-  };
-};
-
-// Should not be allowed - because then null/'null' become impossible to
-// distinguish. Every key MUST be a string period!
-var hasNullAndUndefStringKey = [
-  {uniqueID: 'undefined', val: 'thisIsUndefined'},
-  {uniqueID: 'null', val: 'thisIsNull'}
-];
-var hasNullKey = [
-  {uniqueID: 'thisKeyIsFine', data: []},
-  {uniqueID: 'thisKeyIsAlsoFine', data: []},
-  {uniqueID: null, data: []}
-];
-
-var hasObjectKey = [
-  {uniqueID: 'thisKeyIsFine', data: []},
-  {uniqueID: 'thisKeyIsAlsoFine', data: []},
-  {uniqueID: {}, data: []}
-];
-
-var hasArrayKey = [
-  {uniqueID: 'thisKeyIsFine', data: []},
-  {uniqueID: 'thisKeyIsAlsoFine', data: []},
-  {uniqueID: [], data: []}
-];
-
-// This should be allowed
-var hasNullStringKey = [
-  {uniqueID: 'thisKeyIsFine', data: []},
-  {uniqueID: 'thisKeyIsAlsoFine', data: []},
-  {uniqueID: 'null', data: []}
-];
-
-var hasUndefinedKey = [
-  {uniqueID: 'thisKeyIsFine', data: []},
-  {uniqueID: 'thisKeyIsAlsoFine', data: []},
-  {uniqueID: undefined, data: []}
-];
-
-var hasUndefinedStringKey = [
-  {uniqueID: 'thisKeyIsFine', data: []},
-  {uniqueID: 'thisKeyIsAlsoFine', data: []},
-  {uniqueID: 'undefined', data: []}
-];
-
-var hasPositiveNumericKey = [
-  {uniqueID: 'notANumber', data: []},
-  {uniqueID: '5', data: []},
-  {uniqueID: 'notAnotherNumber',data: []}
-];
-
-var hasZeroStringKey = [
-  {uniqueID: 'greg', data: 'grego'},
-  {uniqueID: '0', data: '0o'},
-  {uniqueID: 'tom', data: 'tomo'}
-];
-
-var hasZeroNumberKey = [
-  {uniqueID: 'greg', data: 'grego'},
-  {uniqueID: 0, data: '0o'},
-  {uniqueID: 'tom', data: 'tomo'}
-];
-
-var hasAllNumericStringKeys = [
-  {uniqueID: '0', name: 'Gregory'},
-  {uniqueID: '2', name: 'James'},
-  {uniqueID: '1', name: 'Tom'}
-];
-
-var hasAllNumericKeys = [
-  {uniqueID: 0, name: 'Gregory'},
-  {uniqueID: 2, name: 'James'},
-  {uniqueID: 1, name: 'Tom'}
-];
-
-var hasAllValidKeys = [
-  {uniqueID: 'keyOne', value: 'valueOne'},
-  {uniqueID: 'keyTwo', value: 'valueTwo'}
-];
-
-var hasDuplicateKeys = [
-  {uniqueID: 'keyOne', value: 'valueOne'},
-  {uniqueID: 'keyTwo', value: 'valueTwo'},
-  {uniqueID: 'keyOne', value: 'valueThree'}
-];
-
-var idEntities = [
-  {uniqueID: 'greg', name: 'Gregory'},
-  {uniqueID: 'james', name: 'James'},
-  {uniqueID: 'tom', name: 'Tom'}
-];
-
-var hasEmptyKey = [
-  {uniqueID: 'greg', name: 'Gregory'},
-  {uniqueID: '', name: 'James'},
-  {uniqueID: 'tom', name: 'Tom'}
-];
-
-var extractUniqueID = function(entity) {
-  return entity.uniqueID;
-};
-
-describe('OrderedMap', function() {
-  beforeEach(function() {
-    require("../../mock-modules").dumpCache();
-    OrderedMap = require("../../OrderedMap");
-  });
-
-  it('should create according to simple object with keys', function() {
-    OrderedMap.fromArray(hasAllValidKeys, extractUniqueID);
-    // Iterate over and ensure key order.
-  });
-
-  it('should create from array when providing an identity CB', function() {
-    expect(function() {
-      OrderedMap.fromArray(idEntities, extractUniqueID);
-    }).not.toThrow();
-  });
-
-  it('should throw if constructing from Array without identity CB', function() {
-    OrderedMap.fromArray(idEntities, extractUniqueID);
-    // Iterate and ensure key order
-  });
-
-  it('should not throw when fromArray extracts a numeric key', function() {
-    expect(function() {
-      OrderedMap.fromArray(hasPositiveNumericKey, extractUniqueID);
-    }).not.toThrow();
-
-  });
-
-  it('should throw when any key is the empty string', function() {
-    expect(function() {
-      OrderedMap.fromArray(hasEmptyKey, extractUniqueID);
-    }).toThrow();
-  });
-
-  it('should not throw when a key is the string "undefined" or "null"',
-    function() {
-      var om = OrderedMap.fromArray(hasNullAndUndefStringKey, extractUniqueID);
-      expect(om.length).toBe(2);
-      expect(om.indexOfKey('undefined')).toBe(0);
-      expect(om.indexOfKey('null')).toBe(1);
-      expect(om.keyAfter('undefined')).toBe('null');
-      expect(om.keyAfter('null')).toBe(undefined);
-      expect(om.keyBefore('undefined')).toBe(undefined);
-      expect(om.has('undefined')).toBe(true);
-      expect(om.has('null')).toBe(true);
-      expect(om.get('undefined').val).toBe('thisIsUndefined');
-      expect(om.get('null').val).toBe('thisIsNull');
-    });
-
-
-  /**
-   * Numeric keys are cast to strings.
-   */
-  it('should not throw when a key is the number zero', function() {
-    var om = OrderedMap.fromArray(hasZeroNumberKey, extractUniqueID);
-    expect(om.length).toBe(3);
-    expect(om.indexOfKey('0')).toBe(1);
-    expect(om.indexOfKey(0)).toBe(1);
-  });
-
-  it('should throw when any key is falsey', function() {
-    expect(function() {
-      OrderedMap.fromArray(hasEmptyStringKey, extractUniqueID);
-    }).toThrow();
-
-    expect(function() {
-      OrderedMap.fromArray(hasNullKey, extractUniqueID);
-    }).toThrow();
-
-    expect(function() {
-      OrderedMap.fromArray(hasUndefinedKey, extractUniqueID);
-    }).toThrow();
-  });
-
-  it('should not throw on string keys "undefined/null"', function() {
-    expect(function() {
-      OrderedMap.fromArray(hasNullStringKey, extractUniqueID);
-    }).not.toThrow();
-
-    expect(function() {
-      OrderedMap.fromArray(hasUndefinedStringKey, extractUniqueID);
-    }).not.toThrow();
-  });
-
-  it('should throw on extracting keys that are not strings/nums', function() {
-    expect(function() {
-      OrderedMap.fromArray(hasObjectKey, extractUniqueID);
-    }).toThrow();
-
-    expect(function() {
-      OrderedMap.fromArray(hasArrayKey, extractUniqueID);
-    }).toThrow();
-  });
-
-  it('should throw if instantiating with duplicate key', function() {
-    expect(function() {
-      OrderedMap.fromArray(hasDuplicateKeys, extractUniqueID);
-    }).toThrow();
-  });
-
-  it('should not throw when a key is the string "0"', function() {
-    var verifyOM = function(om) {
-      expect(om.length).toBe(3);
-      expect(om.indexOfKey('greg')).toBe(0);
-      expect(om.indexOfKey('0')).toBe(1);
-      expect(om.indexOfKey(0)).toBe(1); // Casts on writes and reads.
-      expect(om.indexOfKey('tom')).toBe(2);
-      expect(om.keyAfter('greg')).toBe('0');
-      expect(om.keyAfter('0')).toBe('tom');
-      expect(om.keyAfter(0)).toBe('tom');
-      expect(om.keyAfter('tom')).toBe(undefined);
-      expect(om.keyBefore('greg')).toBe(undefined);
-      expect(om.keyBefore(0)).toBe('greg');
-      expect(om.keyBefore('0')).toBe('greg');
-      expect(om.keyBefore('tom')).toBe('0');
-      expect(om.has('undefined')).toBe(false);
-      expect(om.has(0)).toBe(true);
-      expect(om.has('0')).toBe(true);
-    };
-    var om = OrderedMap.fromArray(hasZeroStringKey, extractUniqueID);
-    verifyOM(om);
-    om = OrderedMap.fromArray(hasZeroNumberKey, extractUniqueID);
-    verifyOM(om);
-  });
-
-  it('should throw when getting invalid public key', function() {
-    var om = OrderedMap.fromArray(hasAllValidKeys, extractUniqueID);
-    expect(function() {
-      om.has(undefined);
-    }).toThrow();
-    expect(function() {
-      om.get(undefined);
-    }).toThrow();
-    expect(function() {
-      om.has(null);
-    }).toThrow();
-    expect(function() {
-      om.get(null);
-    }).toThrow();
-    expect(function() {
-      om.has('');
-    }).toThrow();
-    expect(function() {
-      om.get('');
-    }).toThrow();
-  });
-
-  it('should throw when any key is falsey', function() {
-    expect(function() {
-      OrderedMap.fromArray(hasEmptyStringKey, extractUniqueID);
-    }).toThrow();
-
-    expect(function() {
-      OrderedMap.fromArray(hasNullKey, extractUniqueID);
-    }).toThrow();
-
-    expect(function() {
-      OrderedMap.fromArray(hasUndefinedKey, extractUniqueID);
-    }).toThrow();
-  });
-
-
-  it('should throw when fromArray is passed crazy args', function() {
-    // Test passing another OrderedMap (when it expects a plain object.)
-    // This is probably not what you meant to do! We should error.
-    var validOM = OrderedMap.fromArray(hasAllValidKeys, extractUniqueID);
-    expect(function() {
-      OrderedMap.fromArray({uniqueID: 'asdf'}, extractUniqueID);
-    }).toThrow();
-    expect(function() {
-      OrderedMap.fromArray(validOM, extractUniqueID);
-    }).toThrow();
-  });
-
-  it('should throw when fromArray is passed crazy things', function() {
-    expect(function() {
-      OrderedMap.fromArray(null, extractUniqueID);
-    }).toThrow();
-    expect(function() {
-      OrderedMap.fromArray('stringgg', extractUniqueID);
-    }).toThrow();
-    expect(function() {
-      OrderedMap.fromArray(undefined, extractUniqueID);
-    }).toThrow();
-    expect(function() {
-      OrderedMap.fromArray(new Date(), extractUniqueID);
-    }).toThrow();
-    expect(function() {
-      OrderedMap.fromArray({}, extractUniqueID);
-    }).toThrow();
-
-    // Test failure without extractor
-    expect(function() {
-      OrderedMap.fromArray(idEntities);
-    }).toThrow();
-    expect(function() {
-      OrderedMap.fromArray(idEntities, extractUniqueID);
-    }).not.toThrow();
-  });
-
-  // Testing methods that accept other `OrderedMap`s.
-  it('should throw when from/merge is passed an non-OrderedMap.', function() {
-    // Test passing an array to construction.
-    expect(function() {
-      OrderedMap.from(idEntities, extractUniqueID);
-    }).toThrow();
-
-    // Test passing an array to merge.
-    expect(function() {
-      OrderedMap.fromArray(idEntities, extractUniqueID)
-        .merge(idEntities, extractUniqueID);
-    }).toThrow();
-
-
-    // Test passing a plain object to merge.
-    expect(function() {
-      OrderedMap.fromArray(
-        idEntities,
-        extractUniqueID
-      ).merge({blah: 'willFail'});
-    }).toThrow();
-  });
-
-  it('should throw when accessing key before/after of non-key', function() {
-    var om = OrderedMap.fromArray([
-      {uniqueID: 'first'},
-      {uniqueID: 'two'}], extractUniqueID
-    );
-    expect(function() {
-      om.keyBefore('dog');
-    }).toThrow();
-    expect(function() {
-      om.keyAfter('cat');
-    }).toThrow();
-    expect(function() {
-      om.keyAfter(null);
-    }).toThrow();
-    expect(function() {
-      om.keyAfter(undefined);
-    }).toThrow();
-  });
-
-  it('should throw passing invalid/not-present-keys to before/after',
-    function() {
-      var om = OrderedMap.fromArray([
-        {uniqueID: 'one', val: 'first'},
-        {uniqueID: 'two', val: 'second'},
-        {uniqueID: 'three', val: 'third'},
-        {uniqueID: 'four', val: 'fourth'}
-      ], extractUniqueID);
-
-      expect(function() {
-        om.keyBefore('');
-      }).toThrow();
-      expect(function() {
-        om.keyBefore(null);
-      }).toThrow();
-      expect(function() {
-        om.keyBefore(undefined);
-      }).toThrow();
-      expect(function() {
-        om.keyBefore('notInTheOrderedMap!');
-      }).toThrow();
-
-      expect(function() {
-        om.keyAfter('');
-      }).toThrow();
-      expect(function() {
-        om.keyAfter(null);
-      }).toThrow();
-      expect(function() {
-        om.keyAfter(undefined);
-      }).toThrow();
-      expect(function() {
-        om.keyAfter('notInTheOrderedMap!');
-      }).toThrow();
-
-      expect(function() {
-        om.nthKeyAfter('', 1);
-      }).toThrow();
-      expect(function() {
-        om.nthKeyAfter(null, 1);
-      }).toThrow();
-      expect(function() {
-        om.nthKeyAfter(undefined, 1);
-      }).toThrow();
-      expect(function() {
-        om.nthKeyAfter('notInTheOrderedMap!', 1);
-      }).toThrow();
-
-      expect(function() {
-        om.nthKeyBefore('', 1);
-      }).toThrow();
-      expect(function() {
-        om.nthKeyBefore(null, 1);
-      }).toThrow();
-      expect(function() {
-        om.nthKeyBefore(undefined, 1);
-      }).toThrow();
-      expect(function() {
-        om.nthKeyBefore('notInTheOrderedMap!', 1);
-      }).toThrow();
-    });
-
-  it('should correctly determine the nth key after before', function() {
-    var om = OrderedMap.fromArray([
-      {uniqueID: 'one', val: 'first'},
-      {uniqueID: 'two', val: 'second'},
-      {uniqueID: 'three', val: 'third'},
-      {uniqueID: 'four', val: 'fourth'}
-    ], extractUniqueID);
-    expect(om.keyBefore('one')).toBe(undefined); // first key
-    expect(om.keyBefore('two')).toBe('one');
-    expect(om.keyBefore('three')).toBe('two');
-    expect(om.keyBefore('four')).toBe('three');
-
-    expect(om.keyAfter('one')).toBe('two'); // first key
-    expect(om.keyAfter('two')).toBe('three');
-    expect(om.keyAfter('three')).toBe('four');
-    expect(om.keyAfter('four')).toBe(undefined);
-
-    expect(om.nthKeyBefore('one', 0)).toBe('one'); // first key
-    expect(om.nthKeyBefore('one', 1)).toBe(undefined);
-    expect(om.nthKeyBefore('one', 2)).toBe(undefined);
-    expect(om.nthKeyBefore('two', 0)).toBe('two');
-    expect(om.nthKeyBefore('two', 1)).toBe('one');
-    expect(om.nthKeyBefore('four', 0)).toBe('four');
-    expect(om.nthKeyBefore('four', 1)).toBe('three');
-
-    expect(om.nthKeyAfter('one', 0)).toBe('one');
-    expect(om.nthKeyAfter('one', 1)).toBe('two');
-    expect(om.nthKeyAfter('one', 2)).toBe('three');
-    expect(om.nthKeyAfter('two', 0)).toBe('two');
-    expect(om.nthKeyAfter('two', 1)).toBe('three');
-    expect(om.nthKeyAfter('four', 0)).toBe('four');
-    expect(om.nthKeyAfter('four', 1)).toBe(undefined);
-  });
-
-  it('should compute key indices correctly', function() {
-    var om = OrderedMap.fromArray([
-      {uniqueID: 'one', val: 'first'},
-      {uniqueID: 'two', val: 'second'}
-    ], extractUniqueID);
-    expect(om.keyAtIndex(0)).toBe('one');
-    expect(om.keyAtIndex(1)).toBe('two');
-    expect(om.keyAtIndex(2)).toBe(undefined);
-    expect(om.indexOfKey('one')).toBe(0);
-    expect(om.indexOfKey('two')).toBe(1);
-    expect(om.indexOfKey('nope')).toBe(undefined);
-    expect(function() {
-      om.indexOfKey(null);
-    }).toThrow();
-    expect(function() {
-      om.indexOfKey(undefined);
-    }).toThrow();
-    expect(function() {
-      om.indexOfKey(''); // Empty key is not allowed
-    }).toThrow();
-  });
-
-  it('should compute indices on array that extracted numeric ids', function() {
-    var om = OrderedMap.fromArray(hasZeroStringKey, extractUniqueID);
-    expect(om.keyAtIndex(0)).toBe('greg');
-    expect(om.keyAtIndex(1)).toBe('0');
-    expect(om.keyAtIndex(2)).toBe('tom');
-    expect(om.indexOfKey('greg')).toBe(0);
-    expect(om.indexOfKey('0')).toBe(1);
-    expect(om.indexOfKey('tom')).toBe(2);
-
-
-    var verifyNumericKeys = function(om) {
-      expect(om.keyAtIndex(0)).toBe('0');
-      expect(om.keyAtIndex(1)).toBe('2');
-      expect(om.keyAtIndex(2)).toBe('1');
-      expect(om.indexOfKey('0')).toBe(0);
-      expect(om.indexOfKey('2')).toBe(1); // Proove these are not ordered by
-      expect(om.indexOfKey('1')).toBe(2); // their keys
-    };
-    var omStringNumberKeys =
-      OrderedMap.fromArray(hasAllNumericStringKeys, extractUniqueID);
-    verifyNumericKeys(omStringNumberKeys);
-    var omNumericKeys =
-      OrderedMap.fromArray(hasAllNumericKeys, extractUniqueID);
-    verifyNumericKeys(omNumericKeys);
-  });
-
-  it('should compute indices on mutually exclusive merge', function() {
-    var om = OrderedMap.fromArray([
-      {uniqueID: 'one', val: 'first'},
-      {uniqueID: 'two', val: 'second'}
-    ], extractUniqueID);
-    var om2 = OrderedMap.fromArray([
-      {uniqueID: 'three', val: 'third'}
-    ], extractUniqueID);
-    var res = om.merge(om2);
-
-    expect(res.length).toBe(3);
-
-    expect(res.keyAtIndex(0)).toBe('one');
-    expect(res.keyAtIndex(1)).toBe('two');
-    expect(res.keyAtIndex(2)).toBe('three');
-    expect(res.keyAtIndex(3)).toBe(undefined);
-
-    expect(res.indexOfKey('one')).toBe(0);
-    expect(res.indexOfKey('two')).toBe(1);
-    expect(res.indexOfKey('three')).toBe(2);
-    expect(res.indexOfKey('dog')).toBe(undefined);
-
-    expect(res.has('one')).toBe(true);
-    expect(res.has('two')).toBe(true);
-    expect(res.has('three')).toBe(true);
-    expect(res.has('dog')).toBe(false);
-
-    expect(res.get('one').val).toBe('first');
-    expect(res.get('two').val).toBe('second');
-    expect(res.get('three').val).toBe('third');
-    expect(res.get('dog')).toBe(undefined);
-  });
-
-  it('should compute indices on intersected merge', function() {
-    var oneTwo = OrderedMap.fromArray([
-      {uniqueID: 'one', val: 'first'},
-      {uniqueID: 'two', val: 'secondOM1'}
-    ], extractUniqueID);
-
-    var testOneTwoMergedWithTwoThree = function(res) {
-      expect(res.length).toBe(3);
-      expect(res.keyAtIndex(0)).toBe('one');
-      expect(res.keyAtIndex(1)).toBe('two');
-      expect(res.keyAtIndex(2)).toBe('three');
-      expect(res.keyAtIndex(3)).toBe(undefined);
-      expect(res.indexOfKey('one')).toBe(0);
-      expect(res.indexOfKey('two')).toBe(1);
-      expect(res.indexOfKey('three')).toBe(2);
-      expect(res.indexOfKey('dog')).toBe(undefined);
-      expect(res.has('one')).toBe(true);
-      expect(res.has('two')).toBe(true);
-      expect(res.has('three')).toBe(true);
-      expect(res.has('dog')).toBe(false);
-      expect(res.get('one').val).toBe('first');
-      expect(res.get('two').val).toBe('secondOM2');
-      expect(res.get('three').val).toBe('third');
-      expect(res.get('dog')).toBe(undefined);
-    };
-
-    var result =
-      oneTwo.merge(OrderedMap.fromArray([
-        {uniqueID: 'two', val: 'secondOM2'},
-        {uniqueID: 'three', val: 'third'}
-      ], extractUniqueID));
-    testOneTwoMergedWithTwoThree(result);
-
-    // Everything should be exactly as before, since the ordering of `two` was
-    // already determined by `om`.
-    result = oneTwo.merge(
-      OrderedMap.fromArray([
-        {uniqueID: 'three', val: 'third'},
-        {uniqueID: 'two', val:'secondOM2'}
-      ], extractUniqueID)
-    );
-    testOneTwoMergedWithTwoThree(result);
-
-
-    var testTwoThreeMergedWithOneTwo = function(res) {
-      expect(res.length).toBe(3);
-      expect(res.keyAtIndex(0)).toBe('two');
-      expect(res.keyAtIndex(1)).toBe('three');
-      expect(res.keyAtIndex(2)).toBe('one');
-      expect(res.keyAtIndex(3)).toBe(undefined);
-      expect(res.indexOfKey('two')).toBe(0);
-      expect(res.indexOfKey('three')).toBe(1);
-      expect(res.indexOfKey('one')).toBe(2);
-      expect(res.indexOfKey('cat')).toBe(undefined);
-      expect(res.has('two')).toBe(true);
-      expect(res.has('three')).toBe(true);
-      expect(res.has('one')).toBe(true);
-      expect(res.has('dog')).toBe(false);
-      expect(res.get('one').val).toBe('first');
-      expect(res.get('two').val).toBe('secondOM1');
-      expect(res.get('three').val).toBe('third');
-      expect(res.get('dog')).toBe(undefined);
-    };
-    result = OrderedMap.fromArray([
-        {uniqueID: 'two', val: 'secondOM2'},
-        {uniqueID: 'three', val: 'third'}
-      ], extractUniqueID).merge(oneTwo);
-    testTwoThreeMergedWithOneTwo(result);
-
-  });
-
-  it('should merge mutually exclusive keys to the end.', function() {
-    var om = OrderedMap.fromArray([
-      {uniqueID: 'one', val: 'first'},
-      {uniqueID: 'two', val: 'second'}
-    ], extractUniqueID);
-    var om2 = OrderedMap.fromArray([
-      {uniqueID: 'three', val: 'first'},
-      {uniqueID: 'four', val: 'second'}
-    ], extractUniqueID);
-    var res = om.merge(om2);
-    expect(res.length).toBe(4);
-
-  });
-
-  it('should map correctly', function() {
-    var om = OrderedMap.fromArray([
-      {uniqueID: 'x', val: 'xx'},
-      {uniqueID: 'y', val: 'yy'},
-      {uniqueID: 'z', val: 'zz'}
-    ], extractUniqueID);
-    var scope = {justToTestScope: 'justTestingScope'};
-    var verifyResult = function(omResult) {
-      expect(omResult.length).toBe(3);
-      expect(omResult.keyAtIndex(0)).toBe('x');
-      expect(omResult.keyAtIndex(1)).toBe('y');
-      expect(omResult.keyAtIndex(2)).toBe('z');
-      expect(omResult.get('x').val).toBe('xxx0justTestingScope');
-      expect(omResult.get('y').val).toBe('yyy1justTestingScope');
-      expect(omResult.get('z').val).toBe('zzz2justTestingScope');
-    };
-    var resultOM = om.map(function(itm, key, count) {
-      return {
-        uniqueID: itm.uniqueID,
-        val: itm.val + key + count + this.justToTestScope
-      };
-    }, scope);
-    verifyResult(resultOM);
-
-    var resArray = [];
-    om.forEach(function(itm, key, count) {
-      resArray.push({
-        uniqueID: itm.uniqueID,
-        val: itm.val + key + count + this.justToTestScope
-      });
-    }, scope);
-    resultOM = OrderedMap.fromArray(resArray, extractUniqueID);
-    verifyResult(resultOM);
-  });
-
-  it('should filter correctly', function() {
-    var om = OrderedMap.fromArray([
-      {uniqueID: 'x', val: 'xx'},
-      {uniqueID: 'y', val: 'yy'},
-      {uniqueID: 'z', val: 'zz'}
-    ], extractUniqueID);
-    var scope = {justToTestScope: 'justTestingScope'};
-
-    var filteringCallback = function(item, key, indexInOriginal) {
-      expect(this).toBe(scope);
-      expect(key === 'x' || key === 'y' || key === 'z').toBe(true);
-      if (key === 'x') {
-        expect(item.val).toBe('xx');
-        expect(indexInOriginal).toBe(0);
-        return false;
-      } else if (key === 'y') {
-        expect(item.val).toBe('yy');
-        expect(indexInOriginal).toBe(1);
-        return true;
-      } else {
-        expect(item.val).toBe('zz');
-        expect(indexInOriginal).toBe(2);
-        return true;
-      }
-    };
-
-    var verifyResult = function(omResult) {
-      expect(omResult.length).toBe(2);
-      expect(omResult.keyAtIndex(0)).toBe('y');
-      expect(omResult.keyAtIndex(1)).toBe('z');
-      expect(omResult.has('x')).toBe(false);
-      expect(omResult.has('z')).toBe(true);
-      expect(omResult.get('z').val).toBe('zz');
-      expect(omResult.has('y')).toBe(true);
-      expect(omResult.get('y').val).toBe('yy');
-    };
-
-    var resultOM = om.filter(filteringCallback, scope);
-    verifyResult(resultOM);
-  });
-
-  it('should throw when providing invalid ranges to ranging', function() {
-    var om = OrderedMap.fromArray([
-      {uniqueID: 'x', val: 'xx'},
-      {uniqueID: 'y', val: 'yy'},
-      {uniqueID: 'z', val: 'zz'}
-    ], extractUniqueID);
-    var scope = {justToTestScope: 'justTestingScope'};
-
-    expect(function() {
-      om.mapRange(duplicate, 0, 3, scope);
-    }).not.toThrow();
-    expect(function() {
-      om.filterRange(duplicate, 0, 3, scope);
-    }).not.toThrow();
-    expect(function() {
-      om.forEachRange(duplicate, 0, 3, scope);
-    }).not.toThrow();
-    expect(function() {
-      om.mapKeyRange(duplicate, 'x' , 3, scope);
-    }).not.toThrow();
-    expect(function() {
-      om.forEachKeyRange(duplicate, 'x', 3, scope);
-    }).not.toThrow();
-
-    expect(function() {
-      om.mapRange(duplicate, 0, 4, scope);
-    }).toThrow();
-    expect(function() {
-      om.filterRange(duplicate, 0, 4, scope);
-    }).toThrow();
-    expect(function() {
-      om.forEachRange(duplicate, 0, 4, scope);
-    }).toThrow();
-    expect(function() {
-      om.mapKeyRange(duplicate, 'x', null, scope);
-    }).toThrow();
-    expect(function() {
-      om.forEachKeyRange(duplicate, 'x', null, scope);
-    }).toThrow();
-
-    expect(function() {
-      om.mapRange(duplicate, -1, 1, scope);
-    }).toThrow();
-    expect(function() {
-      om.filterRange(duplicate, -1, 1, scope);
-    }).toThrow();
-    expect(function() {
-      om.forEachRange(duplicate, -1, 1, scope);
-    }).toThrow();
-    expect(function() {
-      om.mapKeyRange(duplicate, null, 'y', scope);
-    }).toThrow();
-    expect(function() {
-      om.forEachKeyRange(duplicate, null, 'y', scope);
-    }).toThrow();
-
-    expect(function() {
-      om.mapRange(duplicate, 0, 0, scope);
-    }).not.toThrow();
-    expect(function() {
-      om.filterRange(duplicate, 0, 0, scope);
-    }).not.toThrow();
-    expect(function() {
-      om.forEachRange(duplicate, 0, 0, scope);
-    }).not.toThrow();
-    expect(function() {
-      om.mapKeyRange(duplicate, 'x', 'x', scope);
-    }).not.toThrow();
-    expect(function() {
-      om.forEachKeyRange(duplicate, 'x', 'x', scope);
-    }).not.toThrow();
-
-    expect(function() {
-      om.mapRange(duplicate, 0, -1, scope);
-    }).toThrow();
-    expect(function() {
-      om.filterRange(duplicate, 0, -1, scope);
-    }).toThrow();
-    expect(function() {
-      om.forEachRange(duplicate, 0, -1, scope);
-    }).toThrow();
-    expect(function() {
-      om.mapKeyRange(duplicate, 'x', null, scope);
-    }).toThrow();
-    expect(function() {
-      om.forEachKeyRange(duplicate, 'x', null, scope);
-    }).toThrow();
-
-    expect(function() {
-      om.mapRange(duplicate, 2, 1, scope);
-    }).not.toThrow();
-    expect(function() {
-      om.filterRange(duplicate, 2, 1, scope);
-    }).not.toThrow();
-    expect(function() {
-      om.forEachRange(duplicate, 2, 1, scope);
-    }).not.toThrow();
-    expect(function() {
-      om.mapKeyRange(duplicate, 'z', 'z', scope);
-    }).not.toThrow();
-    expect(function() {
-      om.forEachKeyRange(duplicate, 'z', 'z', scope);
-    }).not.toThrow();
-
-    expect(function() {
-      om.mapRange(duplicate, 2, 2, scope);
-    }).toThrow();
-    expect(function() {
-      om.filterRange(duplicate, 2, 2, scope);
-    }).toThrow();
-    expect(function() {
-      om.forEachRange(duplicate, 2, 2, scope);
-    }).toThrow();
-    expect(function() {
-      om.mapKeyRange(duplicate, 'z', null, scope);
-    }).toThrow();
-    expect(function() {
-      om.forEachKeyRange(duplicate, 'z', null, scope);
-    }).toThrow();
-
-    // Provide keys in reverse order - should throw.
-    expect(function() {
-      om.mapKeyRange(duplicate, 'y', 'x', scope);
-    }).toThrow();
-    expect(function() {
-      om.forEachKeyRange(duplicate, 'y', 'x', scope);
-    }).toThrow();
-  });
-
-  // TEST length zero map, or keyrange start===end
-
-  it('should map range correctly', function() {
-    var om = OrderedMap.fromArray([
-      {uniqueID: 'x', val: 'xx'},
-      {uniqueID: 'y', val: 'yy'},
-      {uniqueID: 'z', val: 'zz'}
-    ], extractUniqueID);
-    var scope = {justToTestScope: 'justTestingScope'};
-    var verifyThreeItems = function(omResult) {
-      expect(omResult.length).toBe(3);
-      expect(omResult.keyAtIndex(0)).toBe('x');
-      expect(omResult.keyAtIndex(1)).toBe('y');
-      expect(omResult.keyAtIndex(2)).toBe('z');
-      expect(omResult.get('x').val).toBe('xxx0justTestingScope');
-      expect(omResult.get('y').val).toBe('yyy1justTestingScope');
-      expect(omResult.get('z').val).toBe('zzz2justTestingScope');
-    };
-    var verifyFirstTwoItems = function(omResult) {
-      expect(omResult.length).toBe(2);
-      expect(omResult.keyAtIndex(0)).toBe('x');
-      expect(omResult.keyAtIndex(1)).toBe('y');
-      expect(omResult.get('x').val).toBe('xxx0justTestingScope');
-      expect(omResult.get('y').val).toBe('yyy1justTestingScope');
-    };
-
-    var verifyLastTwoItems = function(omResult) {
-      expect(omResult.length).toBe(2);
-      expect(omResult.keyAtIndex(0)).toBe('y');
-      expect(omResult.keyAtIndex(1)).toBe('z');
-      expect(omResult.get('y').val).toBe('yyy1justTestingScope');
-      expect(omResult.get('z').val).toBe('zzz2justTestingScope');
-    };
-
-    var verifyMiddleItem = function(omResult) {
-      expect(omResult.length).toBe(1);
-      expect(omResult.keyAtIndex(0)).toBe('y');
-      expect(omResult.get('y').val).toBe('yyy1justTestingScope');
-    };
-
-    var verifyEmpty = function(omResult) {
-      expect(omResult.length).toBe(0);
-    };
-
-    var omResultThree = om.mapRange(duplicate, 0, 3, scope);
-    verifyThreeItems(omResultThree);
-    var resArray = [];
-    var pushToResArray = function(itm, key, count) {
-      resArray.push({
-        uniqueID: itm.uniqueID,
-        val: itm.val + key + count + this.justToTestScope
-      });
-    };
-
-    om.forEachRange(pushToResArray, 0, 3, scope);
-    omResultThree = OrderedMap.fromArray(resArray, extractUniqueID);
-    verifyThreeItems(omResultThree);
-
-    var omResultFirstTwo = om.mapRange(duplicate, 0, 2, scope);
-    verifyFirstTwoItems(omResultFirstTwo);
-    resArray = [];
-    om.forEachRange(pushToResArray, 0, 2, scope);
-    omResultFirstTwo = OrderedMap.fromArray(resArray, extractUniqueID);
-    verifyFirstTwoItems(omResultFirstTwo);
-
-    var omResultLastTwo = om.mapRange(duplicate, 1, 2, scope);
-    verifyLastTwoItems(omResultLastTwo);
-    resArray = [];
-    om.forEachRange(pushToResArray, 1, 2, scope);
-    omResultLastTwo = OrderedMap.fromArray(resArray, extractUniqueID);
-    verifyLastTwoItems(omResultLastTwo);
-
-    var omResultMiddle = om.mapRange(duplicate, 1, 1, scope);
-    verifyMiddleItem(omResultMiddle);
-    resArray = [];
-    om.forEachRange(pushToResArray, 1, 1, scope);
-    omResultMiddle = OrderedMap.fromArray(resArray, extractUniqueID);
-    verifyMiddleItem(omResultMiddle);
-
-    var omResultNone = om.mapRange(duplicate, 1, 0, scope);
-    verifyEmpty(omResultNone);
-  });
-
-  it('should extract the original array correctly', function() {
-    var sourceArray = [
-      {uniqueID: 'x', val: 'xx'},
-      {uniqueID: 'y', val: 'yy'},
-      {uniqueID: 'z', val: 'zz'}
-    ];
-    var om = OrderedMap.fromArray(sourceArray, extractUniqueID);
-    expect(om.toArray()).toEqual(sourceArray);
-  });
-});
diff --git a/React/utils/__tests__/Transaction-test.js b/React/utils/__tests__/Transaction-test.js
deleted file mode 100644
index 739df7f347..0000000000
--- a/React/utils/__tests__/Transaction-test.js
+++ /dev/null
@@ -1,314 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @emails react-core
- */
-
-"use strict";
-
-var Transaction;
-var mixInto;
-
-var INIT_ERRORED = 'initErrored';     // Just a dummy value to check for.
-describe('Transaction', function() {
-  beforeEach(function() {
-    require("../../mock-modules").dumpCache();
-    Transaction = require("../../Transaction");
-    mixInto = require("../../mixInto");
-  });
-
-  /**
-   * We should not invoke closers for inits that failed. We should pass init
-   * return values to closers when those inits are successful. We should not
-   * invoke the actual method when any of the initializers fail.
-   */
-  it('should invoke closers with/only-with init returns', function() {
-    var throwInInit = function() {
-      throw new Error('close[0] should receive Transaction.OBSERVED_ERROR');
-    };
-
-    var performSideEffect;
-    var dontPerformThis = function() {
-      performSideEffect = 'This should never be set to this';
-    };
-
-    /**
-     * New test Transaction subclass.
-     */
-    var TestTransaction = function() {
-      this.reinitializeTransaction();
-      this.firstCloseParam = INIT_ERRORED;   // WON'T be set to something else
-      this.secondCloseParam = INIT_ERRORED;  // WILL be set to something else
-      this.lastCloseParam = INIT_ERRORED;    // WON'T be set to something else
-    };
-    mixInto(TestTransaction, Transaction.Mixin);
-    TestTransaction.prototype.getTransactionWrappers = function() {
-      return [
-        {
-          initialize: throwInInit,
-          close: function(initResult) {
-            this.firstCloseParam = initResult;
-          }
-        },
-        {
-          initialize: function() { return 'asdf'; },
-          close: function(initResult) {
-            this.secondCloseParam = initResult;
-          }
-        },
-        {
-          initialize: throwInInit,
-          close: function(initResult) {
-            this.lastCloseParam = initResult;
-          }
-        }
-      ];
-    };
-
-    var transaction = new TestTransaction();
-
-    expect(function() {
-      transaction.perform(dontPerformThis);
-    }).toThrow();
-
-    expect(performSideEffect).toBe(undefined);
-    expect(transaction.firstCloseParam).toBe(INIT_ERRORED);
-    expect(transaction.secondCloseParam).toBe('asdf');
-    expect(transaction.lastCloseParam).toBe(INIT_ERRORED);
-    expect(transaction.isInTransaction()).toBe(false);
-  });
-
-  it('should invoke closers and wrapped method when inits success', function() {
-
-    var performSideEffect;
-    /**
-     * New test Transaction subclass.
-     */
-    var TestTransaction = function() {
-      this.reinitializeTransaction();
-      this.firstCloseParam = INIT_ERRORED;   // WON'T be set to something else
-      this.secondCloseParam = INIT_ERRORED;  // WILL be set to something else
-      this.lastCloseParam = INIT_ERRORED;    // WON'T be set to something else
-    };
-    mixInto(TestTransaction, Transaction.Mixin);
-    TestTransaction.prototype.getTransactionWrappers = function() {
-      return [
-        {
-          initialize: function() {
-            return 'firstResult';
-          },
-          close: function(initResult) {
-            this.firstCloseParam = initResult;
-          }
-        },
-        {
-          initialize: function() {
-            return 'secondResult';
-          },
-          close: function(initResult) {
-            this.secondCloseParam = initResult;
-          }
-        },
-        {
-          initialize: function() {
-            return 'thirdResult';
-          },
-          close: function(initResult) {
-            this.lastCloseParam = initResult;
-          }
-        }
-      ];
-    };
-
-    var transaction = new TestTransaction();
-
-    transaction.perform(function() {
-      performSideEffect = 'SIDE_EFFECT';
-    });
-
-    expect(performSideEffect).toBe('SIDE_EFFECT');
-    expect(transaction.firstCloseParam).toBe('firstResult');
-    expect(transaction.secondCloseParam).toBe('secondResult');
-    expect(transaction.lastCloseParam).toBe('thirdResult');
-    expect(transaction.isInTransaction()).toBe(false);
-  });
-
-  /**
-   * When the operation throws, the transaction should throw, but all of the
-   * error-free closers should execute gracefully without issue. If a closer
-   * throws an error, the transaction should prefer to throw the error
-   * encountered earlier in the operation.
-   */
-  it('should throw when wrapped operation throws', function() {
-
-    var performSideEffect;
-    /**
-     * New test Transaction subclass.
-     */
-    var TestTransaction = function() {
-      this.reinitializeTransaction();
-      this.firstCloseParam = INIT_ERRORED;   // WON'T be set to something else
-      this.secondCloseParam = INIT_ERRORED;  // WILL be set to something else
-      this.lastCloseParam = INIT_ERRORED;    // WON'T be set to something else
-    };
-    mixInto(TestTransaction, Transaction.Mixin);
-    // Now, none of the close/inits throw, but the operation we wrap will throw.
-    TestTransaction.prototype.getTransactionWrappers = function() {
-      return [
-        {
-          initialize: function() {
-            return 'firstResult';
-          },
-          close: function(initResult) {
-            this.firstCloseParam = initResult;
-          }
-        },
-        {
-          initialize: function() {
-            return 'secondResult';
-          },
-          close: function(initResult) {
-            this.secondCloseParam = initResult;
-          }
-        },
-        {
-          initialize: function() {
-            return 'thirdResult';
-          },
-          close: function(initResult) {
-            this.lastCloseParam = initResult;
-          }
-        },
-        {
-          initialize: function() {
-            return 'fourthResult';
-          },
-          close: function(initResult) {
-            throw new Error('The transaction should throw a TypeError.');
-          }
-        }
-      ];
-    };
-
-    var transaction = new TestTransaction();
-
-    expect(function() {
-      var isTypeError = false;
-      try {
-        transaction.perform(function() {
-          throw new TypeError("Thrown in main wrapped operation");
-        });
-      } catch (err) {
-        isTypeError = (err instanceof TypeError);
-      }
-      return isTypeError;
-    }()).toBe(true);
-
-    expect(performSideEffect).toBe(undefined);
-    expect(transaction.firstCloseParam).toBe('firstResult');
-    expect(transaction.secondCloseParam).toBe('secondResult');
-    expect(transaction.lastCloseParam).toBe('thirdResult');
-    expect(transaction.isInTransaction()).toBe(false);
-  });
-
-  it('should throw errors in transaction close', function() {
-    var TestTransaction = function() {
-      this.reinitializeTransaction();
-    };
-    mixInto(TestTransaction, Transaction.Mixin);
-    var exceptionMsg = 'This exception should throw.';
-    TestTransaction.prototype.getTransactionWrappers = function() {
-      return [
-        {
-          close: function(initResult) {
-            throw new Error(exceptionMsg);
-          }
-        }
-      ];
-    };
-
-    var transaction = new TestTransaction();
-    expect(function() {
-      transaction.perform(function() {});
-    }).toThrow(exceptionMsg);
-  });
-
-  it('should allow nesting of transactions', function() {
-    var performSideEffect;
-    var nestedPerformSideEffect;
-    /**
-     * New test Transaction subclass.
-     */
-    var TestTransaction = function() {
-      this.reinitializeTransaction();
-      this.firstCloseParam = INIT_ERRORED;   // WON'T be set to something else
-      this.secondCloseParam = INIT_ERRORED;  // WILL be set to something else
-      this.lastCloseParam = INIT_ERRORED;    // WON'T be set to something else
-    };
-    mixInto(TestTransaction, Transaction.Mixin);
-    TestTransaction.prototype.getTransactionWrappers = function() {
-      return [
-        {
-          initialize: function() {
-            return 'firstResult';
-          },
-          close: function(initResult) {
-            this.firstCloseParam = initResult;
-          }
-        },
-        {
-          initialize: function() {
-            this.nestedTransaction = new NestedTransaction();
-          },
-          close: function() {
-            // Test performing a transaction in another transaction's close()
-            this.nestedTransaction.perform(function() {
-              nestedPerformSideEffect = 'NESTED_SIDE_EFFECT';
-            });
-          }
-        }
-      ];
-    };
-
-    var NestedTransaction = function() {
-      this.reinitializeTransaction();
-    };
-    mixInto(NestedTransaction, Transaction.Mixin);
-    NestedTransaction.prototype.getTransactionWrappers = function() {
-      return [{
-        initialize: function() {
-          this.hasInitializedNested = true;
-        },
-        close: function() {
-          this.hasClosedNested = true;
-        }
-      }];
-    };
-
-    var transaction = new TestTransaction();
-
-    transaction.perform(function() {
-      performSideEffect = 'SIDE_EFFECT';
-    });
-
-    expect(performSideEffect).toBe('SIDE_EFFECT');
-    expect(nestedPerformSideEffect).toBe('NESTED_SIDE_EFFECT');
-    expect(transaction.firstCloseParam).toBe('firstResult');
-    expect(transaction.isInTransaction()).toBe(false);
-    expect(transaction.nestedTransaction.hasClosedNested).toBe(true);
-    expect(transaction.nestedTransaction.hasInitializedNested).toBe(true);
-    expect(transaction.nestedTransaction.isInTransaction()).toBe(false);
-  });
-});
diff --git a/React/utils/__tests__/joinClasses-test.js b/React/utils/__tests__/joinClasses-test.js
deleted file mode 100644
index 7cf4e6649b..0000000000
--- a/React/utils/__tests__/joinClasses-test.js
+++ /dev/null
@@ -1,57 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @emails react-core
- */
-
-"use strict";
-
-require("../../mock-modules").dontMock('joinClasses');
-
-var joinClasses = require("../../joinClasses");
-
-describe('joinClasses', function() {
-
-  it('should return a single className', function() {
-    expect(joinClasses('aaa')).toEqual('aaa');
-  });
-
-  it('should join two classes together', function() {
-    var aaa = 'aaa';
-    var bbb = 'bbb';
-    expect(joinClasses(aaa, bbb)).toEqual('aaa bbb');
-  });
-
-  it('should join many classes together', function() {
-    var aaa = 'aaa';
-    var bbb = 'bbb';
-    var ccc = 'ccc';
-    var ddd = 'ddd';
-    var eee = 'eee';
-    expect(joinClasses(aaa, bbb, ccc, ddd, eee)).toEqual('aaa bbb ccc ddd eee');
-  });
-
-  it('should omit undefined and empty classes', function() {
-    var aaa = 'aaa';
-    var bbb;
-    var ccc = null;
-    var ddd = '';
-    var eee = 'eee';
-    expect(joinClasses(bbb)).toEqual('');
-    expect(joinClasses(bbb, bbb, bbb)).toEqual('');
-    expect(joinClasses(aaa, bbb, ccc, ddd, eee)).toEqual('aaa eee');
-  });
-
-});
diff --git a/React/utils/__tests__/keyMirror-test.js b/React/utils/__tests__/keyMirror-test.js
deleted file mode 100644
index fef3c1b2ea..0000000000
--- a/React/utils/__tests__/keyMirror-test.js
+++ /dev/null
@@ -1,71 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @emails react-core
- */
-
-"use strict";
-
-require("../../mock-modules").dontMock('keyMirror');
-
-var keyMirror = require("../../keyMirror");
-
-describe('keyMirror', function() {
-  it('should create an object with values matching keys provided', function() {
-    var mirror = keyMirror({
-      foo: null,
-      bar: true,
-      "baz": { some: "object" },
-      qux: undefined
-    });
-    expect('foo' in mirror).toBe(true);
-    expect(mirror.foo).toBe('foo');
-    expect('bar' in mirror).toBe(true);
-    expect(mirror.bar).toBe('bar');
-    expect('baz' in mirror).toBe(true);
-    expect(mirror.baz).toBe('baz');
-    expect('qux' in mirror).toBe(true);
-    expect(mirror.qux).toBe('qux');
-  });
-
-  it('should not use properties from prototypes', function() {
-    function Klass() {
-      this.useMeToo = true;
-    }
-    Klass.prototype.doNotUse = true;
-    var instance = new Klass();
-    instance.useMe = true;
-
-    var mirror = keyMirror(instance);
-
-    expect('doNotUse' in mirror).toBe(false);
-    expect('useMe' in mirror).toBe(true);
-    expect('useMeToo' in mirror).toBe(true);
-  });
-
-  it('should throw when a non-object argument is used', function() {
-    [null, undefined, 0, 7, ['uno'], true, "string"].forEach(function(testVal) {
-      expect(keyMirror.bind(null, testVal)).toThrow();
-    });
-  });
-
-  it('should work when "constructor" is a key', function() {
-    var obj = { constructor: true };
-    expect(keyMirror.bind(null, obj)).not.toThrow();
-    var mirror = keyMirror(obj);
-    expect('constructor' in mirror).toBe(true);
-  });
-});
-
diff --git a/React/utils/__tests__/mapChildren-test.js b/React/utils/__tests__/mapChildren-test.js
deleted file mode 100644
index 05888d86ab..0000000000
--- a/React/utils/__tests__/mapChildren-test.js
+++ /dev/null
@@ -1 +0,0 @@
-throw new Error("nonexistent module required: utils/__tests__/mapChildren-test");
\ No newline at end of file
diff --git a/React/utils/__tests__/memoizeStringOnly-test.js b/React/utils/__tests__/memoizeStringOnly-test.js
deleted file mode 100644
index a9f357d2a6..0000000000
--- a/React/utils/__tests__/memoizeStringOnly-test.js
+++ /dev/null
@@ -1,37 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @emails react-core
- */
-
-"use strict";
-
-describe('memoizeStringOnly', function() {
-  var memoizeStringOnly;
-
-  beforeEach(function() {
-    require("../../mock-modules").dumpCache();
-    memoizeStringOnly = require("../../memoizeStringOnly");
-  });
-
-  it('should be transparent to callers', function() {
-    var callback = function(string) {
-      return string;
-    };
-    var memoized = memoizeStringOnly(callback);
-
-    expect(memoized('foo'), callback('foo'));
-  });
-});
diff --git a/React/utils/__tests__/mergeFuncs-test.js b/React/utils/__tests__/mergeFuncs-test.js
deleted file mode 100644
index c16dfdabf1..0000000000
--- a/React/utils/__tests__/mergeFuncs-test.js
+++ /dev/null
@@ -1,983 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @emails react-core
- */
-
-"use strict";
-
-require("../../mock-modules")
-    .dontMock('mergeHelpers')
-    .dontMock('merge')
-    .dontMock('mergeDeep')
-    .dontMock('mergeInto')
-    .dontMock('mergeDeepInto');
-
-var mergeHelpers;
-var merge;
-var mergeInto;
-var mergeDeep;
-var mergeDeepInto;
-
-var isTerminal;
-var MAX_MERGE_DEPTH;
-
-/**
- * Simple helper to traverse an object, calling the callback (cb) on every
- * nonTerminal node it finds. It stops once it reaches the maximum depth,
- * because we know that the merge functions shouldn't merge past that depth
- * anyways. If you don't "stop" once reaching the MAX_MERGE_DEPTH, there won't
- * be a practical way to traverse circular structures.
- */
-var traverseUntilLeaves = function(obj, cb, depth) {
-  if ((depth || 0) >= MAX_MERGE_DEPTH) {
-    return;
-  }
-  var key;
-  if (!isTerminal(obj) && !Array.isArray(obj)) {
-    cb(obj);
-    for (key in obj) {
-      if (!obj.hasOwnProperty(key)) {
-        continue;
-      }
-      traverseUntilLeaves(obj[key], cb, (depth || 0) + 1);
-    }
-  }
-};
-
-/*
- * Checks that the structure of two merged objects are identical.  Checks
- * MAX_LEVEL because we don't want to block other unit tests if I have an
- * infinite loop.
- */
-var MAX_LEVEL = 50;
-var structureEquals = function(one, two, levelParam) {
-  var level = levelParam || 0;
-  var oneKey;
-  var twoKey;
-  if (level > MAX_LEVEL) {
-    throw new Error('structure equals computation explored too many levels');
-  }
-  if (isTerminal(one) && isTerminal(two)) {
-    return one === two;
-  } else if (!isTerminal(one) && !isTerminal(two)) {
-    var allInOneAreInTwo = true;
-    for (oneKey in one) {
-      if (!one.hasOwnProperty(oneKey)) {
-        continue;
-      }
-      if (!structureEquals(one[oneKey], two[oneKey], level + 1)) {
-        allInOneAreInTwo = false;
-      }
-    }
-    var allInTwoAreInOne = true;
-    for (twoKey in two) {
-      if (!two.hasOwnProperty(twoKey)) {
-        continue;
-      }
-      if (!structureEquals(two[twoKey], one[twoKey], level + 1)) {
-        allInTwoAreInOne = false;
-      }
-    }
-    // Sure, the computations overlap a bit.
-    return allInOneAreInTwo && allInTwoAreInOne;
-  } else {
-    return false;
-  }
-};
-
-
-var makeCircular = function() {
-  var obj = {};
-  obj.self = obj;
-  return obj;
-};
-
-
-
-/**
- * Not a symmetric function. Checks if there are any node references
- * (nonTerminal [non-string, non-null, etc]) that exist in inThis. See
- * sharesOnlyTerminalMemory.
- */
-var hasNoNodeReferencesIn = function(obj, inThis) {
-  traverseUntilLeaves(obj, function(nonTerm) {
-    traverseUntilLeaves(inThis, function(inThisNonTerm) {
-      if (inThisNonTerm === nonTerm) {
-        return false;
-      }
-    });
-  });
-  return true;
-};
-
-/**
- * Checks that two objects share no memory references with each other (except
- * possibly at the terminal nodes (such as strings etc)). This is used to test
- * isolation of memory. When certain merge operations occur we need to ensure
- * that we did not leak references across objects.
- */
-var sharesOnlyTerminalMemory = function(a, b) {
-  return hasNoNodeReferencesIn(a, b) && hasNoNodeReferencesIn(b, a);
-};
-
-/**
- * Tests all of the merging functions. You provide it data that describes what
- * a deep merge looks like and what a shallow merge looks like. It will make
- * sure that various input/output contracts are adhered to, in addition to
- * ensuring that various guarantees about side-effects are upheld.
- * The test data must provide functions createOne/createTwo as a means to
- * create test data for objects one/two respsectively - each time these
- * functions must return pristine copies so that we can test for side effects
- * correctly.
- */
-var testAllMerges = function(testData) {
-  var createOne = testData.createOne;
-  var createTwo = testData.createTwo;
-  var one;
-  var two;
-
-  /*
-   * Test merge()
-   */
-  one = createOne();
-  two = createTwo();
-  if (testData.mergeShouldThrow) {
-    expect(function() {
-      merge(one, two);
-    }).toThrow();
-  } else {
-    var mergeRes = merge(one, two);
-    if (testData.shallowResultShouldBe) {
-      expect(structureEquals(
-        mergeRes,
-        testData.shallowResultShouldBe)
-      ).toBe(true);
-    }
-    // Ensure the result is not the exact same object memory reference.
-    expect(mergeRes === one).toBe(false);
-  }
-
-  /*
-   * Test mergeInto()
-   */
-  one = createOne();
-  two = createTwo();
-  if (testData.mergeIntoShouldThrow) {
-    expect(function() {
-      mergeInto(one, two);
-    }).toThrow();
-  } else {
-    var mergeIntoRes = mergeInto(one, two);
-    if (testData.shallowResultShouldBe) {
-      expect(structureEquals(
-        one,
-        testData.shallowResultShouldBe)
-      ).toBe(true);
-    }
-    /*
-     * Ensure it's the exact same object reference
-     * TODO: We should ensure that for every object path p in one points to
-     * the original object reference in one before the mutation.
-     */
-    expect(mergeIntoRes === undefined).toBe(true);
-  }
-
-  /*
-   * Test mergeDeep()
-   */
-  one = createOne();
-  two = createTwo();
-  if (testData.mergeDeepShouldThrow) {
-    expect(function() {
-      mergeDeep(one, two, testData.arrayStrategy);
-    }).toThrow();
-  } else {
-    var mergeDeepRes = mergeDeep(one, two, testData.arrayStrategy);
-    if (testData.deepResultShouldBe) {
-      expect(structureEquals(
-        mergeDeepRes,
-        testData.deepResultShouldBe)
-      ).toBe(true);
-    }
-    expect(sharesOnlyTerminalMemory(mergeDeepRes, one)).toBe(true);
-    expect(sharesOnlyTerminalMemory(mergeDeepRes, two)).toBe(true);
-  }
-
-  /*
-   * Test mergeDeepInto()
-   */
-  one = createOne();
-  two = createTwo();
-  if (testData.mergeDeepIntoShouldThrow) {
-    expect(function() {
-      mergeDeepInto(one, two, testData.arrayStrategy);
-    }).toThrow();
-  } else {
-    var mergeDeepIntoRes = mergeDeepInto(one, two, testData.arrayStrategy);
-    expect(mergeDeepIntoRes).toBe(undefined);
-    if (testData.deepResultShouldBe) {
-      expect(structureEquals(
-        one,
-        testData.deepResultShouldBe)
-      ).toBe(true);
-    }
-    expect(mergeDeepIntoRes === undefined).toBe(true);
-    expect(sharesOnlyTerminalMemory(one, two)).toBe(true);
-  }
-
-};
-
-/**
- * ReactTextWithEntities is not a React component, but rather a helper function
- * that returns an array. You can use that array as a helper function when
- * constructing a structure.
- */
-describe('mergeFuncs', function() {
-  beforeEach(function() {
-    require("../../mock-modules").dumpCache();
-    mergeHelpers = require("../../mergeHelpers");
-    merge = require("../../merge");
-    mergeInto = require("../../mergeInto");
-    mergeDeep = require("../../mergeDeep");
-    mergeDeepInto = require("../../mergeDeepInto");
-    isTerminal = mergeHelpers.isTerminal;
-    MAX_MERGE_DEPTH = mergeHelpers.MAX_MERGE_DEPTH;
-  });
-
-  var twoLevelsDeep = function() {
-    return {
-      shallowObject: {
-        deepObject: {
-          a: 'a',
-          b: 'b'
-        },
-        deepObject2: {
-          one: 'one',
-          two: 'two'
-        }
-      }
-    };
-  };
-
-  it('should not throw if first argument is circular', function() {
-    testAllMerges({
-      createOne: makeCircular,
-      createTwo: function() { return {thisOneIsNotCircular: true}; },
-      mergeShouldThrow: false,
-      mergeIntoShouldThrow: false,
-      mergeDeepShouldThrow: true,
-      mergeDeepIntoShouldThrow: false
-    });
-  });
-
-  it('should throw if second argument is circular', function() {
-    testAllMerges({
-      createOne: function() { return {thisOneIsNotCircular: true}; },
-      createTwo: makeCircular,
-      mergeShouldThrow: false,
-      mergeIntoShouldThrow: false,
-      mergeDeepShouldThrow: true,
-      mergeDeepIntoShouldThrow: true
-    });
-  });
-
-  it('should throw if something deep is circular in second param', function() {
-    testAllMerges({
-      createOne: function() { return {thisOneIsNotCircular: true}; },
-      createTwo: function() {
-        return {
-          deeper: {
-            deeper: makeCircular()
-          }
-        };
-      },
-      mergeShouldThrow: false,
-      mergeIntoShouldThrow: false,
-      mergeDeepShouldThrow: true,
-      mergeDeepIntoShouldThrow: true
-    });
-  });
-
-  it('should throw if something deep is circular in first param', function() {
-    testAllMerges({
-      createOne: function() {
-        return {
-          deeper: {
-            deeper: makeCircular()
-          }
-        };
-      },
-      createTwo: function() { return {thisOneIsNotCircular: true}; },
-      mergeShouldThrow: false,
-      mergeIntoShouldThrow: false,
-      mergeDeepShouldThrow: true,
-      mergeDeepIntoShouldThrow: false
-    });
-  });
-
-
-  it('should throw exceptions on invalid data/params', function() {
-    testAllMerges({
-      createOne: function() { return []; },
-      createTwo: function() { return {}; },
-      mergeShouldThrow: true,
-      mergeIntoShouldThrow: true,
-      mergeDeepShouldThrow: true,
-      mergeDeepIntoShouldThrow: true
-    });
-    testAllMerges({
-      createOne: function() { return {}; },
-      createTwo: function() { return []; },
-      mergeShouldThrow: true,
-      mergeIntoShouldThrow: true,
-      mergeDeepShouldThrow: true,
-      mergeDeepIntoShouldThrow: true
-    });
-    testAllMerges({
-      createOne: function() { return []; },
-      createTwo: function() { return {hasDeepStructure: 'yes'}; },
-      mergeShouldThrow: true,
-      mergeIntoShouldThrow: true,
-      mergeDeepShouldThrow: true,
-      mergeDeepIntoShouldThrow: true
-    });
-    testAllMerges({
-      createOne: function() { return {hasDeepStructure: 'yes'}; },
-      createTwo: function() { return []; },
-      mergeShouldThrow: true,
-      mergeIntoShouldThrow: true,
-      mergeDeepShouldThrow: true,
-      mergeDeepIntoShouldThrow: true
-    });
-    testAllMerges({
-      createOne: function() { return {hasDeepStructure: 'yes'}; },
-      createTwo: function() { return []; },
-      mergeShouldThrow: true,
-      mergeIntoShouldThrow: true,
-      mergeDeepShouldThrow: true,
-      mergeDeepIntoShouldThrow: true
-    });
-    /*
-     * mergeInto functions do not accept an empty first parameter. There would
-     * be nothing to mutate!
-     */
-    testAllMerges({
-      createOne: function() { return null; },
-      createTwo: function() { return {field: 'yes'}; },
-      mergeIntoShouldThrow: true,
-      mergeDeepIntoShouldThrow: true,
-      shallowResultShouldBe: {field: 'yes'},
-      deepResultShouldBe: {field: 'yes'}
-    });
-    testAllMerges({
-      createOne: function() { return undefined; },
-      createTwo: function() { return {field: 'yes'}; },
-      mergeIntoShouldThrow: true,
-      mergeDeepIntoShouldThrow: true,
-      shallowResultShouldBe: {field: 'yes'},
-      deepResultShouldBe: {field: 'yes'}
-    });
-    // Every merge function accepts an empty second parameter.
-    testAllMerges({
-      createOne: function() { return {field: 'yes'}; },
-      createTwo: function() { return null; },
-      shallowResultShouldBe: {field: 'yes'},
-      deepResultShouldBe: {field: 'yes'}
-    });
-    testAllMerges({
-      createOne: function() { return null; },
-      createTwo: function() { return null; },
-      deepResultShouldBe: {},
-      shallowResultShouldBe: {},
-      mergeIntoShouldThrow: true,
-      mergeDeepIntoShouldThrow: true
-    });
-    testAllMerges({
-      createOne: function() { return {field: 'yes'}; },
-      createTwo: function() { return undefined; },
-      shallowResultShouldBe: {field: 'yes'},
-      deepResultShouldBe: {field: 'yes'}
-    });
-    testAllMerges({
-      createOne: function() { return 0; },
-      createTwo: function() { return {field: 'yes'}; },
-      mergeShouldThrow: true,
-      mergeIntoShouldThrow: true,
-      mergeDeepShouldThrow: true,
-      mergeDeepIntoShouldThrow: true
-    });
-    /*
-     * The fact that the second param is empty shouldn't change that we still
-     * error on arrays.
-     */
-    testAllMerges({
-      createOne: function() { return []; },
-      createTwo: function() { return undefined; },
-      mergeShouldThrow: true,
-      mergeIntoShouldThrow: true,
-      mergeDeepShouldThrow: true,
-      mergeDeepIntoShouldThrow: true
-    });
-    testAllMerges({
-      createOne: function() { return {field: 'yes'}; },
-      createTwo: function() { return null; },
-      shallowResultShouldBe: {field: 'yes'},
-      deepResultShouldBe: {field: 'yes'}
-    });
-  });
-
-
-  it('should merge very deep objects correctly.',
-    function() {
-      testAllMerges({
-        createOne: function() {
-          return {
-            shouldBeClobberedByNull: {
-              color: 'blue'
-            },
-            shouldGetTwoFieldsWhenDeepMerge: {
-              firstField: { color: 'red' }
-            },
-            shouldRemainUndefined: undefined,
-            shouldRemainFour: 4,
-            shouldRemainZero: 0,
-            shouldBeClobberedByObj: 0
-          };
-        },
-        createTwo: function() {
-          return {
-            shouldBeClobberedByNull: null,
-            shouldGetTwoFieldsWhenDeepMerge: {
-              secondField: { color: 'black' }
-            },
-            shouldBeClobberedByObj: { thisObj: true }
-          };
-        },
-        shallowResultShouldBe: {
-          shouldBeClobberedByNull: null,
-          // only gets one field when merged shallowly
-          shouldGetTwoFieldsWhenDeepMerge: {
-            secondField: { color: 'black' }
-          },
-          shouldRemainUndefined: undefined,
-          shouldRemainFour: 4,
-          shouldRemainZero: 0,
-          shouldBeClobberedByObj: { thisObj: true }
-        },
-        deepResultShouldBe: {
-          shouldRemainUndefined: undefined,
-          shouldRemainFour: 4,
-          shouldRemainZero: 0,
-          shouldBeClobberedByNull: null,
-          shouldGetTwoFieldsWhenDeepMerge: {
-            firstField: { color: 'red' },
-            secondField: { color: 'black' }
-          },
-          shouldBeClobberedByObj: { thisObj: true }
-        }
-      });
-    }
-  );
-
-  it(
-    'should not throw with one non-colliding arrays with no arrayStrategy',
-    function() {
-      testAllMerges({
-        createOne: function() { return { hasDeepStructure: 'yes' }; },
-        createTwo: function() { return { hasArrayDeeper: [] }; },
-        mergeShouldThrow: false,
-        mergeIntoShouldThrow: false,
-        mergeDeepShouldThrow: false,
-        mergeDeepIntoShouldThrow: false,
-        shallowResultShouldBe: {
-          hasDeepStructure: 'yes',
-          hasArrayDeeper: []
-        },
-        deepResultShouldBe: {
-          hasDeepStructure: 'yes',
-          hasArrayDeeper: []
-        }
-      });
-    }
-  );
-
-  it(
-    'should not throw with two non-colliding arrays with no arrayStrategy',
-    function() {
-      testAllMerges({
-        createOne: function() {
-          return {
-            arrayOne: [1]
-          };
-        },
-        createTwo: function() {
-          return {
-            arrayTwo: [2]
-          };
-        },
-        arrayStrategy: mergeHelpers.ArrayStrategies.Clobber,
-        mergeShouldThrow: false,
-        mergeIntoShouldThrow: false,
-        mergeDeepShouldThrow: false,
-        mergeDeepIntoShouldThrow: false
-      });
-    }
-  ),
-
-  it('should throw if no arrayStrategy supplied on Array merges', function() {
-    testAllMerges({
-      createOne: function() {
-        return {
-          arrayOne: [1]
-        };
-      },
-      createTwo: function() {
-        return {
-          arrayOne: [9]
-        };
-      },
-      shallowResultShouldBe: {
-        arrayOne: [9]
-      },
-      // Doesn't throw on the shallow versions.
-      mergeShouldThrow: false,
-      mergeIntoShouldThrow: false,
-      mergeDeepShouldThrow: true,
-      mergeDeepIntoShouldThrow: true
-    });
-  }),
-
-  it('should not throw if never forced to merge two Arrays', function() {
-    testAllMerges({
-      createOne: function() {
-        return {
-          arrayOne: [1]
-        };
-      },
-      createTwo: function() {
-        return {
-          arrayTwo: [9]    // <-- See, never forced to merge with arrayOne
-        };
-      },
-      shallowResultShouldBe: {
-        arrayOne: [1],
-        arrayTwo: [9]
-      },
-      // Doesn't throw on the shallow versions.
-      mergeShouldThrow: false,
-      mergeIntoShouldThrow: false,
-      mergeDeepShouldThrow: false,
-      mergeDeepIntoShouldThrow: false
-    });
-  }),
-
-  it(
-    'should correctly deep merge Arrays with arrayStrategy clobber',
-    function() {
-      testAllMerges({
-        createOne: function() {
-          return {
-            deep: {
-              array: [1],
-              nonArray: {
-                hi: 'hi'
-              }
-            }
-          };
-        },
-        createTwo: function() {
-          return {
-            deep: {
-              array: [10,11, {deepFieldInArray: 'yes'}],
-              nonArray: {
-                bye: 'bye'
-              }
-            }
-          };
-        },
-        shallowResultShouldBe: {
-          deep: {
-            array: [10,11, {deepFieldInArray: 'yes'}],
-            nonArray: {
-              bye: 'bye'
-            }
-          }
-        },
-        deepResultShouldBe: {
-          deep: {
-            array: [10,11, {deepFieldInArray: 'yes'}],
-            nonArray: {
-              hi: 'hi',
-              bye: 'bye'
-            }
-          }
-        },
-        arrayStrategy: mergeHelpers.ArrayStrategies.Clobber,
-        mergeShouldThrow: false,
-        mergeIntoShouldThrow: false,
-        mergeDeepShouldThrow: false,
-        mergeDeepIntoShouldThrow: false
-      });
-    }
-  ),
-
-
-  it(
-    'should correctly deep merge Arrays with arrayStrategy indexByIndex',
-    function() {
-      testAllMerges({
-        createOne: function() {
-          return {
-            deep: {
-              array: [{
-                atIndexZero: {
-                  indexZeroGreeting: 'You Are At Index Zero',
-                  indexZeroStatus: false
-                }
-              }]
-            }
-          };
-        },
-        createTwo: function() {
-          return {
-            deep: {
-              array: [{
-                atIndexZero: {
-                  indexZeroStatus: true,
-                  newFieldAtIndexZero: 'newField'
-                }
-              },
-              {
-                atIndexOne: {
-                  nothingOriginallyAtThisIndex: true
-                }
-              }]
-            }
-          };
-        },
-        shallowResultShouldBe: {
-          deep: {
-            array: [{
-              atIndexZero: {
-                indexZeroStatus: true,
-                newFieldAtIndexZero: 'newField'
-              }
-            },
-            {
-              atIndexOne: {
-                nothingOriginallyAtThisIndex: true
-              }
-            }]
-          }
-        },
-        deepResultShouldBe: {
-          deep: {
-            array: [{
-              atIndexZero: {
-                indexZeroGreeting: 'You Are At Index Zero',  // <-- See!?
-                indexZeroStatus: true,
-                newFieldAtIndexZero: 'newField'
-              }
-            },
-            {
-              atIndexOne: {
-                nothingOriginallyAtThisIndex: true
-              }
-            }]
-          }
-        },
-        arrayStrategy: mergeHelpers.ArrayStrategies.IndexByIndex,
-        mergeShouldThrow: false,
-        mergeIntoShouldThrow: false,
-        mergeDeepShouldThrow: false,
-        mergeDeepIntoShouldThrow: false
-      }
-    );
-  }),
-
-  it('should merge deep data correctly', function() {
-    var mergeData = {
-      shallowObject: {
-        deepObject: {
-          c: 'c',
-          d: 'd'
-        },
-        deepObject2: {
-          three: 'three',
-          four: 'four'
-        }
-      }
-    };
-    var deepResult = {
-      shallowObject: {
-        deepObject: {
-          a: 'a',
-          b: 'b',
-          c: 'c',
-          d: 'd'
-        },
-        deepObject2: {
-          one: 'one',
-          two: 'two',
-          three: 'three',
-          four: 'four'
-        }
-      }
-    };
-    var shallowResult = mergeData; // The same
-
-    testAllMerges({
-      createOne: function() { return twoLevelsDeep(); },
-      createTwo: function() { return mergeData; },
-      mergeShouldThrow: false,
-      mergeIntoShouldThrow: false,
-      mergeDeepShouldThrow: false,
-      mergeDeepIntoShouldThrow: false,
-      deepResultShouldBe: deepResult,
-      shallowResultShouldBe: shallowResult
-    });
-  });
-
-  it('should fill in complementing regions of data trees', function() {
-    var mergeData = {
-      shallowObject: {
-        newDepth: {
-          hello: 'goodbye'
-        }
-      }
-    };
-    var deepResult = {
-      shallowObject: {
-        deepObject: {
-          a: 'a',
-          b: 'b'
-        },
-        deepObject2: {
-          one: 'one',
-          two: 'two'
-        },
-        // This is added!
-        newDepth: {
-          hello: 'goodbye'
-        }
-      }
-    };
-    var shallowResult = mergeData; // The same
-
-    testAllMerges({
-      createOne: function() { return twoLevelsDeep(); },
-      createTwo: function() { return mergeData; },
-      // The deep merge of the two
-      deepResultShouldBe: deepResult,
-      shallowResultShouldBe: shallowResult
-    });
-  });
-
-  /**
-   * Arrays and Objects wipe out terminals (and vice versa).
-   */
-  it('should clobber terminals with objects/arrays vice versa', function() {
-    var makeOne = function() {
-      return {
-        thisFieldDoesNothing: {},
-        deep: {
-          // Objects
-          thisShouldSwitchFromObjectToTerminal: {hello: 'goodbye'},
-          thisShouldSwitchFromTerminalToObject: 'yes',
-
-          // Arrays
-          thisShouldSwitchFromArrayToTerminal: ['goodbye'],
-          thisShouldSwitchFromTerminalToArray: 'yes'
-        }
-      };
-    };
-    var makeTwo = function() {
-      return {
-        deep: {
-          // Objects
-          thisShouldSwitchFromObjectToTerminal: 'terminal',
-          thisShouldSwitchFromTerminalToObject: {nowItsAnObject: 'yay'},
-
-          // Arrays
-          thisShouldSwitchFromArrayToTerminal: 'terminal',
-          thisShouldSwitchFromTerminalToArray: ['yay']
-        }
-      };
-    };
-    var deepResult = {
-      thisFieldDoesNothing: {
-
-      },
-      deep: {
-        // Objects
-        thisShouldSwitchFromObjectToTerminal: 'terminal',
-        thisShouldSwitchFromTerminalToObject: {nowItsAnObject: 'yay'},
-
-        // Arrays
-        thisShouldSwitchFromArrayToTerminal: 'terminal',
-        thisShouldSwitchFromTerminalToArray: ['yay']
-      }
-    };
-
-    testAllMerges({
-      createOne: makeOne,
-      createTwo: makeTwo,
-      deepResultShouldBe: deepResult,       // The deep merge of the two
-      shallowResultShouldBe: deepResult     // The same this time.
-    });
-  });
-
-  /**
-   * Arrays wipe out Objects and Objects wipe out Arrays.
-   */
-  it('should clobber terminals with objects/arrays vice versa', function() {
-    var makeOne = function() {
-      return {
-        thisFieldDoesNothing: {},
-        deep: {
-          thisShouldSwitchFromObjectToArray: {hello: 'goodbye'},
-          thisShouldSwitchFromArrayToObject: [1,2,3]
-        }
-      };
-    };
-    var makeTwo = function() {
-      return {
-        deep: {
-          thisShouldSwitchFromObjectToArray: [7,8,9],
-          thisShouldSwitchFromArrayToObject: {iUsedToBeAnArray:true}
-        }
-      };
-    };
-    var deepResult = {
-      thisFieldDoesNothing: {},
-      deep: {
-        thisShouldSwitchFromObjectToArray: [7,8,9],
-        thisShouldSwitchFromArrayToObject: {iUsedToBeAnArray:true}
-      }
-    };
-
-    testAllMerges({
-      createOne: makeOne,
-      createTwo: makeTwo,
-      deepResultShouldBe: deepResult,       // The deep merge of the two
-      shallowResultShouldBe: deepResult     // The same this time.
-    });
-  });
-
-  it(
-    'should not clobber terminals/objects/arrays that are not over-written',
-    function() {
-      testAllMerges({
-        createOne: function() {
-          return {
-            deep: {
-              terminal: 'I am a terminal',
-              object: {iAmAnObject: true},
-              array: [1,2,3]
-            }
-          };
-        },
-        createTwo: function() {
-          return {
-            deep: {
-              completelyDifferentField: 'no collision here!'
-            }
-          };
-        },
-        shallowResultShouldBe: {
-          deep: {
-            completelyDifferentField: 'no collision here!'
-          }
-        },
-        deepResultShouldBe: {
-          deep: {
-            completelyDifferentField: 'no collision here!',
-            terminal: 'I am a terminal',
-            object: {iAmAnObject: true},
-            array: [1,2,3]
-          }
-        },
-        mergeShouldThrow: false,
-        mergeIntoShouldThrow: false,
-        mergeDeepShouldThrow: false,
-        mergeDeepIntoShouldThrow: false
-      }
-    );
-  }),
-
-  it('should correctly clobber terminals with cloned arrays', function() {
-    testAllMerges({
-      createOne: function() {
-        return {
-          deep: {
-            changesFromTermToArray: 'I am a terminal'
-          }
-        };
-      },
-      createTwo: function() {
-        return {
-          deep: {
-            changesFromTermToArray: ['I', 'am', 'an', 'array']
-          }
-        };
-      },
-      shallowResultShouldBe: {
-        deep: {
-          changesFromTermToArray: ['I', 'am', 'an', 'array']
-        }
-      },
-      deepResultShouldBe: {
-        deep: {
-          changesFromTermToArray: ['I', 'am', 'an', 'array']
-        }
-      },
-      mergeShouldThrow: false,
-      mergeIntoShouldThrow: false,
-      mergeDeepShouldThrow: false,
-      mergeDeepIntoShouldThrow: false
-    });
-  }),
-
-  it('should detect terminals correctly in merge* functions', function() {
-    var boolResFalse = isTerminal(false);
-    expect(boolResFalse).toBe(true);
-
-    var boolResTrue = isTerminal(true);
-    expect(boolResTrue).toBe(true);
-
-    var numRes = isTerminal(123);
-    expect(numRes).toBe(true);
-
-    var zeroRes = isTerminal(0);
-    expect(zeroRes).toBe(true);
-
-    var stringRes = isTerminal('i am a string');
-    expect(stringRes).toBe(true);
-
-    var objLiteralRes = isTerminal({somethingHere: true});
-    expect(objLiteralRes).toBe(false);
-
-    var undefRes = isTerminal(undefined);
-    expect(undefRes).toBe(true);
-
-    var nullRes = isTerminal(null);
-    expect(nullRes).toBe(true);
-
-    var arrRes = isTerminal([]);
-    expect(arrRes).toBe(false);
-  });
-});
-
diff --git a/React/utils/__tests__/objFilter-test.js b/React/utils/__tests__/objFilter-test.js
deleted file mode 100644
index 317db4c608..0000000000
--- a/React/utils/__tests__/objFilter-test.js
+++ /dev/null
@@ -1,88 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @emails react-core
- */
-
-"use strict";
-
-var objFilter = require("../../objFilter");
-
-describe('objFilter', function() {
-
-  var obj = {
-    A: 'apple',
-    B: 'banana',
-    C: 'coconut',
-    D: 'durian',
-    E: 'elderberry',
-    F: 'fig',
-    G: 'guava',
-    H: 'hackberry'
-  };
-
-  it('should accept null', function() {
-    var filtered = objFilter(null, function() {});
-    expect(filtered).toBe(null);
-  });
-
-  it('should return true to create copy', function() {
-    var filtered = objFilter(obj, function() {
-      return true;
-    });
-    expect(filtered).not.toBe(obj);
-    expect(filtered).toEqual(obj);
-  });
-
-  it('should return empty object for a falsey func', function() {
-    var filtered = objFilter(obj, function() {
-      return false;
-    });
-    expect(filtered).toEqual({});
-  });
-
-  it('should filter based on value', function() {
-    var filtered = objFilter(obj, function(value) {
-      return value.indexOf('berry') !== -1;
-    });
-    expect(filtered).toEqual({
-      E: 'elderberry',
-      H: 'hackberry'
-    });
-  });
-
-  it('should filter based on key', function() {
-    var filtered = objFilter(obj, function(value, key) {
-      return (/[AEIOU]/).test(key);
-    });
-    expect(filtered).toEqual({
-      A: 'apple',
-      E: 'elderberry'
-    });
-  });
-
-  it('should filter based on iteration', function() {
-    var filtered = objFilter(obj, function(value, key, iteration) {
-      return iteration % 2;
-    });
-    expect(filtered).toEqual({
-      B: 'banana',
-      D: 'durian',
-      F: 'fig',
-      H: 'hackberry'
-    });
-  });
-
-});
diff --git a/React/utils/__tests__/objMap-test.js b/React/utils/__tests__/objMap-test.js
deleted file mode 100644
index 1c9140c5ce..0000000000
--- a/React/utils/__tests__/objMap-test.js
+++ /dev/null
@@ -1,113 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @emails react-core
- */
-
-"use strict";
-
-var objMap = require("../../objMap");
-
-describe('objMap', function() {
-
-  var obj = {
-    A: 'apple',
-    B: 'banana',
-    C: 'coconut',
-    D: 'durian',
-    E: 'elderberry',
-    F: 'fig',
-    G: 'guava',
-    H: 'hackberry'
-  };
-
-  it('should accept null', function() {
-    var mapped = objMap(null, function() {});
-    expect(mapped).toBe(null);
-  });
-
-  it('should return value to create copy', function() {
-    var mapped = objMap(obj, function(value) {
-      return value;
-    });
-    expect(mapped).not.toBe(obj);
-    expect(mapped).toEqual(obj);
-  });
-
-  it('should always retain keys', function() {
-    var mapped = objMap(obj, function() {
-      return null;
-    });
-    expect(mapped).toEqual({
-      A: null,
-      B: null,
-      C: null,
-      D: null,
-      E: null,
-      F: null,
-      G: null,
-      H: null
-    });
-  });
-
-  it('should map values', function() {
-    var mapped = objMap(obj, function (value) {
-      return value.toUpperCase();
-    });
-    expect(mapped).toEqual({
-      A: 'APPLE',
-      B: 'BANANA',
-      C: 'COCONUT',
-      D: 'DURIAN',
-      E: 'ELDERBERRY',
-      F: 'FIG',
-      G: 'GUAVA',
-      H: 'HACKBERRY'
-    });
-  });
-
-  it('should map keys', function() {
-    var mapped = objMap(obj, function (value, key) {
-      return key;
-    });
-    expect(mapped).toEqual({
-      A: 'A',
-      B: 'B',
-      C: 'C',
-      D: 'D',
-      E: 'E',
-      F: 'F',
-      G: 'G',
-      H: 'H'
-    });
-  });
-
-  it('should map iterations', function() {
-    var mapped = objMap(obj, function (value, key, iteration) {
-      return iteration;
-    });
-    expect(mapped).toEqual({
-      A: 0,
-      B: 1,
-      C: 2,
-      D: 3,
-      E: 4,
-      F: 5,
-      G: 6,
-      H: 7
-    });
-  });
-
-});
diff --git a/React/vendor/error/__tests__/erx-test.js b/React/vendor/error/__tests__/erx-test.js
deleted file mode 100644
index 7d98445e2c..0000000000
--- a/React/vendor/error/__tests__/erx-test.js
+++ /dev/null
@@ -1,58 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2004-present Facebook. All Rights Reserved.
- *
- * @emails catchen@fb.com
- * @emails javascript@lists.facebook.com
- */
-
-require("../../../mock-modules")
-  .dontMock('erx')
-  .dontMock('ex');
-
-describe('erx', function() {
-  var erx = require("../../../erx");
-  var ex = require("../../../ex");
-
-  it('should always reverse ex if placeholder and argument match', function() {
-    expect(erx(ex('zero argument'))).toEqual(['zero argument']);
-    expect(erx(ex('one argument: %s', 'one')))
-      .toEqual(['one argument: %s', 'one']);
-    expect(erx(ex('two arguments: %s, %s', 'one', 2)))
-      .toEqual(['two arguments: %s, %s', 'one', '2']);
-    expect(erx(ex('three arguments: %s, %s, %s', 'one', 2, { value: 3 })))
-      .toEqual(['three arguments: %s, %s, %s', 'one', '2', '[object Object]']);
-  });
-
-  it('should be idempotent', function() {
-    var messageWithParams = erx(ex('one argument: %s', 'one'));
-    expect(messageWithParams).toEqual(erx(messageWithParams));
-  });
-
-  it('should treat plain text as it was ex-ed with no argument', function() {
-    expect(erx('plain text')).toEqual(['plain text']);
-  });
-
-  it('should work when text was appended/prepended to ex-ed text', function() {
-    expect(erx('prepended text|' + ex('zero argument') + '|appended text'))
-      .toEqual(['prepended text|zero argument|appended text']);
-    expect(erx(
-      'prepended text|' +
-      ex('one argument: %s', 'one') +
-      '|appended text'
-    )).toEqual(['prepended text|one argument: %s|appended text', 'one']);
-  });
-});
diff --git a/React/vendor/error/__tests__/ex-test.js b/React/vendor/error/__tests__/ex-test.js
deleted file mode 100644
index 752748b20a..0000000000
--- a/React/vendor/error/__tests__/ex-test.js
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Copyright 2004-present Facebook. All Rights Reserved.
- *
- * @emails catchen@fb.com
- * @emails javascript@lists.facebook.com
- */
-
-require("../../../mock-modules")
-  .dontMock('ex');
-
-describe('ex', function() {
-  var ex = require("../../../ex");
-
-  it('should convert whatever arguments into one string', function() {
-    expect(typeof ex('zero argument')).toEqual('string');
-    expect(typeof ex('one argument: %s', 'one')).toEqual('string');
-    expect(typeof ex('two arguments: %s, %s', 'one', 2))
-      .toEqual('string');
-    expect(typeof ex('three arguments: %s, %s, %s', 'one', 2, { value: 3 }))
-      .toEqual('string');
-  });
-
-  it('should handle placeholder and argument number mismatch', function() {
-    expect(typeof ex('zero placeholder and one argument', 'one'))
-      .toEqual('string');
-    expect(typeof ex('one placeholder and zero argument: %s'))
-      .toEqual('string');
-  });
-});
diff --git a/all/HtmlReporter.js b/all/HtmlReporter.js
deleted file mode 100644
index 8ed3d3742d..0000000000
--- a/all/HtmlReporter.js
+++ /dev/null
@@ -1,168 +0,0 @@
-var jasmine = require("./jasmine");
-
-exports.HtmlReporter =
-jasmine.HtmlReporter = function(_doc) {
-  var self = this;
-  var doc = _doc || window.document;
-
-  var reporterView;
-
-  var dom = {};
-
-  // Jasmine Reporter Public Interface
-  self.logRunningSpecs = false;
-
-  self.reportRunnerStarting = function(runner) {
-    var specs = runner.specs() || [];
-
-    if (specs.length == 0) {
-      return;
-    }
-
-    createReporterDom(runner.env.versionString());
-    doc.body.appendChild(dom.reporter);
-    setExceptionHandling();
-
-    reporterView = new jasmine.HtmlReporter.ReporterView(dom);
-    reporterView.addSpecs(specs, self.specFilter);
-  };
-
-  self.reportRunnerResults = function(runner) {
-    reporterView && reporterView.complete();
-  };
-
-  self.reportSuiteResults = function(suite) {
-    reporterView.suiteComplete(suite);
-  };
-
-  self.reportSpecStarting = function(spec) {
-    if (self.logRunningSpecs) {
-      self.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
-    }
-  };
-
-  self.reportSpecResults = function(spec) {
-    reporterView.specComplete(spec);
-  };
-
-  self.log = function() {
-    var console = jasmine.getGlobal().console;
-    if (console && console.log) {
-      if (console.log.apply) {
-        console.log.apply(console, arguments);
-      } else {
-        console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
-      }
-    }
-  };
-
-  self.specFilter = function(spec) {
-    if (!focusedSpecName()) {
-      return true;
-    }
-
-    return spec.getFullName().indexOf(focusedSpecName()) === 0;
-  };
-
-  return self;
-
-  function focusedSpecName() {
-    var specName;
-
-    (function memoizeFocusedSpec() {
-      if (specName) {
-        return;
-      }
-
-      var paramMap = [];
-      var params = jasmine.HtmlReporter.parameters(doc);
-
-      for (var i = 0; i < params.length; i++) {
-        var p = params[i].split('=');
-        paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
-      }
-
-      specName = paramMap.spec;
-    })();
-
-    return specName;
-  }
-
-  function createReporterDom(version) {
-    dom.reporter = self.createDom('div', { id: 'HTMLReporter', className: 'jasmine_reporter' },
-      dom.banner = self.createDom('div', { className: 'banner' },
-        self.createDom('span', { className: 'title' }, "Jasmine "),
-        self.createDom('span', { className: 'version' }, version)),
-
-      dom.symbolSummary = self.createDom('ul', {className: 'symbolSummary'}),
-      dom.alert = self.createDom('div', {className: 'alert'},
-        self.createDom('span', { className: 'exceptions' },
-          self.createDom('label', { className: 'label', 'for': 'no_try_catch' }, 'No try/catch'),
-          self.createDom('input', { id: 'no_try_catch', type: 'checkbox' }))),
-      dom.results = self.createDom('div', {className: 'results'},
-        dom.summary = self.createDom('div', { className: 'summary' }),
-        dom.details = self.createDom('div', { id: 'details' }))
-    );
-  }
-
-  function noTryCatch() {
-    return window.location.search.match(/catch=false/);
-  }
-
-  function searchWithCatch() {
-    var params = jasmine.HtmlReporter.parameters(window.document);
-    var removed = false;
-    var i = 0;
-
-    while (!removed && i < params.length) {
-      if (params[i].match(/catch=/)) {
-        params.splice(i, 1);
-        removed = true;
-      }
-      i++;
-    }
-    if (jasmine.CATCH_EXCEPTIONS) {
-      params.push("catch=false");
-    }
-
-    return params.join("&");
-  }
-
-  function setExceptionHandling() {
-    var chxCatch = document.getElementById('no_try_catch');
-
-    if (noTryCatch()) {
-      chxCatch.setAttribute('checked', true);
-      jasmine.CATCH_EXCEPTIONS = false;
-    }
-    chxCatch.onclick = function() {
-      window.location.search = searchWithCatch();
-    };
-  }
-};
-jasmine.HtmlReporter.parameters = function(doc) {
-  var paramStr = doc.location.search.substring(1);
-  var params = [];
-
-  if (paramStr.length > 0) {
-    params = paramStr.split('&');
-  }
-  return params;
-}
-jasmine.HtmlReporter.sectionLink = function(sectionName) {
-  var link = '?';
-  var params = [];
-
-  if (sectionName) {
-    params.push('spec=' + encodeURIComponent(sectionName));
-  }
-  if (!jasmine.CATCH_EXCEPTIONS) {
-    params.push("catch=false");
-  }
-  if (params.length > 0) {
-    link += params.join("&");
-  }
-
-  return link;
-};
-jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter);
diff --git a/all/PrintReporter.js b/all/PrintReporter.js
deleted file mode 100644
index 9ffd94a1dc..0000000000
--- a/all/PrintReporter.js
+++ /dev/null
@@ -1,128 +0,0 @@
-var jasmine = require("./jasmine");
-var diff = require('./diff');
-
-var red = '\u001b[1;41m';
-var reset = '\u001b[0m';
-
-function highlightDifferences(a, b) {
-  var changes = diff.diffChars(a, b);
-
-  var ret = {a: '', b: ''};
-  var change;
-  for (var i = 0, il = changes.length; i < il; i++) {
-    change = changes[i];
-    if (change.added) {
-      ret.b += red + change.value + reset;
-    } else if (change.removed) {
-      ret.a += red + change.value + reset;
-    } else {
-      ret.a += change.value;
-      ret.b += change.value;
-    }
-  }
-  return ret;
-}
-
-function PrintReporter(name, root_directory) {
-  this.skipCount = 0;
-  this.failCount = 0;
-  this.expectCount = 0;
-  this.specCount = 0;
-  this.name = name;
-  this.rootDirectory = root_directory;
-}
-exports.PrintReporter =
-jasmine.PrintReporter = PrintReporter;
-
-PrintReporter.prototype = new jasmine.Reporter();
-// Set verbose=true on the test instance to enable additional logging
-PrintReporter.prototype.verbose = false;
-PrintReporter.prototype._didSpecName = false;
-
-PrintReporter.prototype.reportSpecStarting = function(spec) {
-  this._didSpecName = false;
-  this._spec = spec;
-};
-
-PrintReporter.prototype.reportRunnerResults = function(runner) {
-  // Don't print out the spec name at the end
-  this._didSpecName = true;
-
-  this.log([
-    this.specCount + " spec",
-    this.expectCount + " expect",
-    this.skipCount + " skip",
-    this.failCount + " fail"
-  ].join("  "));
-
-  require("./phantom").exit(this.failCount);
-};
-
-
-PrintReporter.prototype.reportSuiteResults = function(suite) {
-  var results = suite.results();
-  if (this.verbose) {
-    this.log('Suite "' + suite.description + '": ' +
-      results.passedCount + '/' + results.totalCount + ' passed.');
-  }
-
-  // If suite is nested, only count the root suite
-  if (!suite.parentSuite) {
-    this.failCount += results.totalCount - results.passedCount;
-    this.expectCount += results.totalCount;
-  }
-};
-
-PrintReporter.prototype.reportSpecResults = function(spec) {
-  if (this.verbose) {
-    this.log('it... ' +
-      spec.description + ': ' + (spec.results().passed() ? 'pass' : 'fail'));
-  }
-
-  var self = this;
-  var results = spec.results();
-
-  this.specCount += 1;
-
-  if (results.skipped)
-    this.skipCount += 1;
-
-  results.getItems().forEach(function(result) {
-    if (result.type == 'log') {
-      self.log(result.toString());
-    } else if (result.type == 'expect' && result.passed && !result.passed()) {
-      var ppActual = jasmine.pp(result.actual);
-      var ppExpected = jasmine.pp(result.expected);
-
-      var colorDiff = highlightDifferences(ppActual, ppExpected);
-
-      var message = result.message;
-      message = message.replace(ppActual, colorDiff.a);
-      message = message.replace(ppExpected, colorDiff.b);
-
-      self.log(message);
-      if (result.trace.stack) {
-        self.log();
-        result.trace.stack.split('\n').forEach(function(stackFrame) {
-          if (stackFrame.indexOf('/jasmine/lib/jasmine-core') > -1) {
-            return;
-          }
-          if (this.rootDirectory) {
-            stackFrame = stackFrame.replace(this.rootDirectory + '/', '');
-          }
-          self.log('  ' + stackFrame);
-        }.bind(this));
-      }
-    }
-  });
-};
-
-PrintReporter.prototype.log = function(str) {
-  if (!this._didSpecName) {
-    console.log('');
-    console.log(
-      this._spec.suite.description + ': it ' + this._spec.description);
-    this._didSpecName = true;
-  }
-  console.log(str || '');
-};
diff --git a/all/ReporterView.js b/all/ReporterView.js
deleted file mode 100644
index 9d75bae0b9..0000000000
--- a/all/ReporterView.js
+++ /dev/null
@@ -1,166 +0,0 @@
-var jasmine = require("./jasmine");
-
-jasmine.HtmlReporter.ReporterView = function(dom) {
-  this.startedAt = new Date();
-  this.runningSpecCount = 0;
-  this.completeSpecCount = 0;
-  this.passedCount = 0;
-  this.failedCount = 0;
-  this.skippedCount = 0;
-
-  this.createResultsMenu = function() {
-    this.resultsMenu = this.createDom('span', {className: 'resultsMenu bar'},
-      this.summaryMenuItem = this.createDom('a', {className: 'summaryMenuItem', href: "#"}, '0 specs'),
-      ' | ',
-      this.detailsMenuItem = this.createDom('a', {className: 'detailsMenuItem', href: "#"}, '0 failing'));
-
-    this.summaryMenuItem.onclick = function() {
-      dom.reporter.className = dom.reporter.className.replace(/ showDetails/g, '');
-    };
-
-    this.detailsMenuItem.onclick = function() {
-      showDetails();
-    };
-  };
-
-  this.addSpecs = function(specs, specFilter) {
-    this.totalSpecCount = specs.length;
-
-    this.views = {
-      specs: {},
-      suites: {}
-    };
-
-    for (var i = 0; i < specs.length; i++) {
-      var spec = specs[i];
-      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom, this.views);
-      if (specFilter(spec)) {
-        this.runningSpecCount++;
-      }
-    }
-  };
-
-  this.specComplete = function(spec) {
-    this.completeSpecCount++;
-
-    if (isUndefined(this.views.specs[spec.id])) {
-      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom);
-    }
-
-    var specView = this.views.specs[spec.id];
-
-    switch (specView.status()) {
-      case 'passed':
-        this.passedCount++;
-        break;
-
-      case 'failed':
-        this.failedCount++;
-        break;
-
-      case 'skipped':
-        this.skippedCount++;
-        break;
-    }
-
-    specView.refresh();
-    this.refresh();
-  };
-
-  this.suiteComplete = function(suite) {
-    var suiteView = this.views.suites[suite.id];
-    if (isUndefined(suiteView)) {
-      return;
-    }
-    suiteView.refresh();
-  };
-
-  this.refresh = function() {
-
-    if (isUndefined(this.resultsMenu)) {
-      this.createResultsMenu();
-    }
-
-    // currently running UI
-    if (isUndefined(this.runningAlert)) {
-      this.runningAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: "runningAlert bar" });
-      dom.alert.appendChild(this.runningAlert);
-    }
-    this.runningAlert.innerHTML = "Running " + this.completeSpecCount + " of " + specPluralizedFor(this.totalSpecCount);
-
-    // skipped specs UI
-    if (isUndefined(this.skippedAlert)) {
-      this.skippedAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: "skippedAlert bar" });
-    }
-
-    this.skippedAlert.innerHTML = "Skipping " + this.skippedCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
-
-    if (this.skippedCount === 1 && isDefined(dom.alert)) {
-      dom.alert.appendChild(this.skippedAlert);
-    }
-
-    // passing specs UI
-    if (isUndefined(this.passedAlert)) {
-      this.passedAlert = this.createDom('span', { href: jasmine.HtmlReporter.sectionLink(), className: "passingAlert bar" });
-    }
-    this.passedAlert.innerHTML = "Passing " + specPluralizedFor(this.passedCount);
-
-    // failing specs UI
-    if (isUndefined(this.failedAlert)) {
-      this.failedAlert = this.createDom('span', {href: "?", className: "failingAlert bar"});
-    }
-    this.failedAlert.innerHTML = "Failing " + specPluralizedFor(this.failedCount);
-
-    if (this.failedCount === 1 && isDefined(dom.alert)) {
-      dom.alert.appendChild(this.failedAlert);
-      dom.alert.appendChild(this.resultsMenu);
-    }
-
-    // summary info
-    this.summaryMenuItem.innerHTML = "" + specPluralizedFor(this.runningSpecCount);
-    this.detailsMenuItem.innerHTML = "" + this.failedCount + " failing";
-  };
-
-  this.complete = function() {
-    dom.alert.removeChild(this.runningAlert);
-
-    this.skippedAlert.innerHTML = "Ran " + this.runningSpecCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
-
-    if (this.failedCount === 0) {
-      dom.alert.appendChild(this.createDom('span', {className: 'passingAlert bar'}, "Passing " + specPluralizedFor(this.passedCount)));
-    } else {
-      showDetails();
-    }
-
-    dom.banner.appendChild(this.createDom('span', {className: 'duration'}, "finished in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s"));
-  };
-
-  return this;
-
-  function showDetails() {
-    if (dom.reporter.className.search(/showDetails/) === -1) {
-      dom.reporter.className += " showDetails";
-    }
-  }
-
-  function isUndefined(obj) {
-    return typeof obj === 'undefined';
-  }
-
-  function isDefined(obj) {
-    return !isUndefined(obj);
-  }
-
-  function specPluralizedFor(count) {
-    var str = count + " spec";
-    if (count > 1) {
-      str += "s"
-    }
-    return str;
-  }
-
-};
-
-jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.ReporterView);
-
-
diff --git a/all/SpecView.js b/all/SpecView.js
deleted file mode 100644
index 8580bd2a59..0000000000
--- a/all/SpecView.js
+++ /dev/null
@@ -1,81 +0,0 @@
-var jasmine = require("./jasmine");
-
-jasmine.HtmlReporter.SpecView = function(spec, dom, views) {
-  this.spec = spec;
-  this.dom = dom;
-  this.views = views;
-
-  this.symbol = this.createDom('li', { className: 'pending' });
-  this.dom.symbolSummary.appendChild(this.symbol);
-
-  this.summary = this.createDom('div', { className: 'specSummary' },
-    this.createDom('a', {
-      className: 'description',
-      href: jasmine.HtmlReporter.sectionLink(this.spec.getFullName()),
-      title: this.spec.getFullName()
-    }, this.spec.description)
-  );
-
-  this.detail = this.createDom('div', { className: 'specDetail' },
-      this.createDom('a', {
-        className: 'description',
-        href: '?spec=' + encodeURIComponent(this.spec.getFullName()),
-        title: this.spec.getFullName()
-      }, this.spec.getFullName())
-  );
-};
-
-jasmine.HtmlReporter.SpecView.prototype.status = function() {
-  return this.getSpecStatus(this.spec);
-};
-
-jasmine.HtmlReporter.SpecView.prototype.refresh = function() {
-  this.symbol.className = this.status();
-
-  switch (this.status()) {
-    case 'skipped':
-      break;
-
-    case 'passed':
-      this.appendSummaryToSuiteDiv();
-      break;
-
-    case 'failed':
-      this.appendSummaryToSuiteDiv();
-      this.appendFailureDetail();
-      break;
-  }
-};
-
-jasmine.HtmlReporter.SpecView.prototype.appendSummaryToSuiteDiv = function() {
-  this.summary.className += ' ' + this.status();
-  this.appendToSummary(this.spec, this.summary);
-};
-
-jasmine.HtmlReporter.SpecView.prototype.appendFailureDetail = function() {
-  this.detail.className += ' ' + this.status();
-
-  var resultItems = this.spec.results().getItems();
-  var messagesDiv = this.createDom('div', { className: 'messages' });
-
-  for (var i = 0; i < resultItems.length; i++) {
-    var result = resultItems[i];
-
-    if (result.type == 'log') {
-      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
-    } else if (result.type == 'expect' && result.passed && !result.passed()) {
-      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
-
-      if (result.trace.stack) {
-        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
-      }
-    }
-  }
-
-  if (messagesDiv.childNodes.length > 0) {
-    this.detail.appendChild(messagesDiv);
-    this.dom.details.appendChild(this.detail);
-  }
-};
-
-jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SpecView);
\ No newline at end of file
diff --git a/all/SuiteView.js b/all/SuiteView.js
deleted file mode 100644
index 917609e5f5..0000000000
--- a/all/SuiteView.js
+++ /dev/null
@@ -1,24 +0,0 @@
-var jasmine = require("./jasmine");
-
-jasmine.HtmlReporter.SuiteView = function(suite, dom, views) {
-  this.suite = suite;
-  this.dom = dom;
-  this.views = views;
-
-  this.element = this.createDom('div', { className: 'suite' },
-    this.createDom('a', { className: 'description', href: jasmine.HtmlReporter.sectionLink(this.suite.getFullName()) }, this.suite.description)
-  );
-
-  this.appendToSummary(this.suite, this.element);
-};
-
-jasmine.HtmlReporter.SuiteView.prototype.status = function() {
-  return this.getSpecStatus(this.suite);
-};
-
-jasmine.HtmlReporter.SuiteView.prototype.refresh = function() {
-  this.element.className += " " + this.status();
-};
-
-jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SuiteView);
-
diff --git a/all/all.js b/all/all.js
deleted file mode 100644
index 2efe39c514..0000000000
--- a/all/all.js
+++ /dev/null
@@ -1,38 +0,0 @@
-require("./phantom");
-require("./console");
-
-// TODO Also bundle jasmine.css here.
-var jasmine = require("./jasmine");
-require("./jasmine-html");
-require("./jasmine-support");
-
-require("./HtmlReporter");
-require("./PrintReporter");
-require("./ReporterView");
-require("./SpecView");
-require("./SuiteView");
-
-var env = jasmine.getEnv();
-env.addReporter(new jasmine.HtmlReporter);
-env.addReporter(new jasmine.PrintReporter);
-
-function exposeFrom(obj) {
-  obj.spyOn = jasmine.spyOn;
-  obj.it = jasmine.it;
-  obj.xit = jasmine.xit;
-  obj.expect = jasmine.expect;
-  obj.runs = jasmine.runs;
-  obj.waits = jasmine.waits;
-  obj.waitsFor = jasmine.waitsFor;
-  obj.beforeEach = jasmine.beforeEach;
-  obj.afterEach = jasmine.afterEach;
-  obj.describe = jasmine.describe;
-  obj.xdescribe = jasmine.xdescribe;
-  obj.jasmine = jasmine;
-  return obj;
-}
-jasmine.exposeFrom = exposeFrom;
-var global = Function("return this")();
-exposeFrom(global);
-
-module.exports = jasmine;
diff --git a/all/console.js b/all/console.js
deleted file mode 100644
index 259d2cc471..0000000000
--- a/all/console.js
+++ /dev/null
@@ -1,92 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * This module allows interception of console.* method calls, so that
- * listeners other than the native console object can consume logged
- * messages.
- */
-
-var global = Function("return this")();
-var Ap = Array.prototype;
-var slice = Ap.slice;
-
-var nativeConsole;
-if ("console" in global) {
-    var gc = global.console;
-    try { delete global.console } catch (ignored) {}
-    nativeConsole = global.console || gc;
-    global.console = gc;
-}
-
-// Provide a reliable console interface in all browsers.
-global.console = exports;
-
-function makeLogger(method) {
-    var logger = exports[method] = function() {
-        var args = slice.call(arguments);
-        listeners.forEach(function(listener) {
-            listener(method, args, logger);
-        });
-    };
-}
-
-makeLogger("info");
-makeLogger("log");
-makeLogger("debug");
-makeLogger("warn");
-makeLogger("error");
-makeLogger("dir");
-makeLogger("dirxml");
-makeLogger("trace");
-makeLogger("assert");
-makeLogger("count");
-makeLogger("markTimeline");
-makeLogger("profile");
-makeLogger("profileEnd");
-makeLogger("time");
-makeLogger("timeEnd");
-makeLogger("timeStamp");
-makeLogger("group");
-makeLogger("groupCollapsed");
-makeLogger("groupEnd");
-makeLogger("clear");
-
-var listeners = [];
-function addListener(listener) {
-    listeners.push(listener);
-}
-exports.addListener = addListener
-
-function clean(arg) {
-    if (typeof arg === "string") {
-        // Remove any xterm-color escape sequences.
-        // TODO Display colors in console if possible.
-        arg = arg.replace(/\033\[\d+m/g, "");
-    }
-    return arg;
-}
-
-if (nativeConsole) {
-    // If present, the native console object becomes a listener just like
-    // any other.
-    addListener(function(method, args) {
-        var method = nativeConsole[method];
-        if (method) {
-            method.apply(nativeConsole, args.map(clean));
-        } else {
-            // Ignore this call.
-        }
-    });
-}
diff --git a/all/diff.js b/all/diff.js
deleted file mode 100644
index 8cab52c2a6..0000000000
--- a/all/diff.js
+++ /dev/null
@@ -1,349 +0,0 @@
-/* See LICENSE file for terms of use */
-
-/*
- * Text diff implementation.
- * 
- * This library supports the following APIS:
- * JsDiff.diffChars: Character by character diff
- * JsDiff.diffWords: Word (as defined by \b regex) diff which ignores whitespace
- * JsDiff.diffLines: Line based diff
- * 
- * JsDiff.diffCss: Diff targeted at CSS content
- * 
- * These methods are based on the implementation proposed in
- * "An O(ND) Difference Algorithm and its Variations" (Myers, 1986).
- * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927
- */
-var JsDiff = (function() {
-  function clonePath(path) {
-    return { newPos: path.newPos, components: path.components.slice(0) };
-  }
-  function removeEmpty(array) {
-    var ret = [];
-    for (var i = 0; i < array.length; i++) {
-      if (array[i]) {
-        ret.push(array[i]);
-      }
-    }
-    return ret;
-  }
-  function escapeHTML(s) {
-    var n = s;
-    n = n.replace(/&/g, "&amp;");
-    n = n.replace(/</g, "&lt;");
-    n = n.replace(/>/g, "&gt;");
-    n = n.replace(/"/g, "&quot;");
-
-    return n;
-  }
-
-  var fbDiff = function(ignoreWhitespace) {
-    this.ignoreWhitespace = ignoreWhitespace;
-  };
-  fbDiff.prototype = {
-      diff: function(oldString, newString) {
-        // Handle the identity case (this is due to unrolling editLength == 0
-        if (newString == oldString) {
-          return [{ value: newString }];
-        }
-        if (!newString) {
-          return [{ value: oldString, removed: true }];
-        }
-        if (!oldString) {
-          return [{ value: newString, added: true }];
-        }
-
-        newString = this.tokenize(newString);
-        oldString = this.tokenize(oldString);
-
-        var newLen = newString.length, oldLen = oldString.length;
-        var maxEditLength = newLen + oldLen;
-        var bestPath = [{ newPos: -1, components: [] }];
-
-        // Seed editLength = 0
-        var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
-        if (bestPath[0].newPos+1 >= newLen && oldPos+1 >= oldLen) {
-          return bestPath[0].components;
-        }
-
-        for (var editLength = 1; editLength <= maxEditLength; editLength++) {
-          for (var diagonalPath = -1*editLength; diagonalPath <= editLength; diagonalPath+=2) {
-            var basePath;
-            var addPath = bestPath[diagonalPath-1],
-                removePath = bestPath[diagonalPath+1];
-            oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
-            if (addPath) {
-              // No one else is going to attempt to use this value, clear it
-              bestPath[diagonalPath-1] = undefined;
-            }
-
-            var canAdd = addPath && addPath.newPos+1 < newLen;
-            var canRemove = removePath && 0 <= oldPos && oldPos < oldLen;
-            if (!canAdd && !canRemove) {
-              bestPath[diagonalPath] = undefined;
-              continue;
-            }
-
-            // Select the diagonal that we want to branch from. We select the prior
-            // path whose position in the new string is the farthest from the origin
-            // and does not pass the bounds of the diff graph
-            if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) {
-              basePath = clonePath(removePath);
-              this.pushComponent(basePath.components, oldString[oldPos], undefined, true);
-            } else {
-              basePath = clonePath(addPath);
-              basePath.newPos++;
-              this.pushComponent(basePath.components, newString[basePath.newPos], true, undefined);
-            }
-
-            var oldPos = this.extractCommon(basePath, newString, oldString, diagonalPath);
-
-            if (basePath.newPos+1 >= newLen && oldPos+1 >= oldLen) {
-              return basePath.components;
-            } else {
-              bestPath[diagonalPath] = basePath;
-            }
-          }
-        }
-      },
-
-      pushComponent: function(components, value, added, removed) {
-        var last = components[components.length-1];
-        if (last && last.added === added && last.removed === removed) {
-          // We need to clone here as the component clone operation is just
-          // as shallow array clone
-          components[components.length-1] =
-            {value: this.join(last.value, value), added: added, removed: removed };
-        } else {
-          components.push({value: value, added: added, removed: removed });
-        }
-      },
-      extractCommon: function(basePath, newString, oldString, diagonalPath) {
-        var newLen = newString.length,
-            oldLen = oldString.length,
-            newPos = basePath.newPos,
-            oldPos = newPos - diagonalPath;
-        while (newPos+1 < newLen && oldPos+1 < oldLen && this.equals(newString[newPos+1], oldString[oldPos+1])) {
-          newPos++;
-          oldPos++;
-
-          this.pushComponent(basePath.components, newString[newPos], undefined, undefined);
-        }
-        basePath.newPos = newPos;
-        return oldPos;
-      },
-
-      equals: function(left, right) {
-        var reWhitespace = /\S/;
-        if (this.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right)) {
-          return true;
-        } else {
-          return left == right;
-        }
-      },
-      join: function(left, right) {
-        return left + right;
-      },
-      tokenize: function(value) {
-        return value;
-      }
-  };
-
-  var CharDiff = new fbDiff();
-
-  var WordDiff = new fbDiff(true);
-  WordDiff.tokenize = function(value) {
-    return removeEmpty(value.split(/(\s+|\b)/));
-  };
-
-  var CssDiff = new fbDiff(true);
-  CssDiff.tokenize = function(value) {
-    return removeEmpty(value.split(/([{}:;,]|\s+)/));
-  };
-
-  var LineDiff = new fbDiff();
-  LineDiff.tokenize = function(value) {
-    return value.split(/^/m);
-  };
-
-  return {
-    diffChars: function(oldStr, newStr) { return CharDiff.diff(oldStr, newStr); },
-    diffWords: function(oldStr, newStr) { return WordDiff.diff(oldStr, newStr); },
-    diffLines: function(oldStr, newStr) { return LineDiff.diff(oldStr, newStr); },
-
-    diffCss: function(oldStr, newStr) { return CssDiff.diff(oldStr, newStr); },
-
-    createPatch: function(fileName, oldStr, newStr, oldHeader, newHeader) {
-      var ret = [];
-
-      ret.push("Index: " + fileName);
-      ret.push("===================================================================");
-      ret.push("--- " + fileName + (typeof oldHeader === "undefined" ? "" : "\t" + oldHeader));
-      ret.push("+++ " + fileName + (typeof newHeader === "undefined" ? "" : "\t" + newHeader));
-
-      var diff = LineDiff.diff(oldStr, newStr);
-      if (!diff[diff.length-1].value) {
-        diff.pop();   // Remove trailing newline add
-      }
-      diff.push({value: "", lines: []});   // Append an empty value to make cleanup easier
-
-      function contextLines(lines) {
-        return lines.map(function(entry) { return ' ' + entry; });
-      }
-      function eofNL(curRange, i, current) {
-        var last = diff[diff.length-2],
-            isLast = i === diff.length-2,
-            isLastOfType = i === diff.length-3 && (current.added !== last.added || current.removed !== last.removed);
-
-        // Figure out if this is the last line for the given file and missing NL
-        if (!/\n$/.test(current.value) && (isLast || isLastOfType)) {
-          curRange.push('\\ No newline at end of file');
-        }
-      }
-
-      var oldRangeStart = 0, newRangeStart = 0, curRange = [],
-          oldLine = 1, newLine = 1;
-      for (var i = 0; i < diff.length; i++) {
-        var current = diff[i],
-            lines = current.lines || current.value.replace(/\n$/, "").split("\n");
-        current.lines = lines;
-
-        if (current.added || current.removed) {
-          if (!oldRangeStart) {
-            var prev = diff[i-1];
-            oldRangeStart = oldLine;
-            newRangeStart = newLine;
-
-            if (prev) {
-              curRange = contextLines(prev.lines.slice(-4));
-              oldRangeStart -= curRange.length;
-              newRangeStart -= curRange.length;
-            }
-          }
-          curRange.push.apply(curRange, lines.map(function(entry) { return (current.added?"+":"-") + entry; }));
-          eofNL(curRange, i, current);
-
-          if (current.added) {
-            newLine += lines.length;
-          } else {
-            oldLine += lines.length;
-          }
-        } else {
-          if (oldRangeStart) {
-            // Close out any changes that have been output (or join overlapping)
-            if (lines.length <= 8 && i < diff.length-2) {
-              // Overlapping
-              curRange.push.apply(curRange, contextLines(lines));
-            } else {
-              // end the range and output
-              var contextSize = Math.min(lines.length, 4);
-              ret.push(
-                  "@@ -" + oldRangeStart + "," + (oldLine-oldRangeStart+contextSize)
-                  + " +" + newRangeStart + "," + (newLine-newRangeStart+contextSize)
-                  + " @@");
-              ret.push.apply(ret, curRange);
-              ret.push.apply(ret, contextLines(lines.slice(0, contextSize)));
-              if (lines.length <= 4) {
-                eofNL(ret, i, current);
-              }
-
-              oldRangeStart = 0;  newRangeStart = 0; curRange = [];
-            }
-          }
-          oldLine += lines.length;
-          newLine += lines.length;
-        }
-      }
-
-      return ret.join('\n') + '\n';
-    },
-
-    applyPatch: function(oldStr, uniDiff) {
-      var diffstr = uniDiff.split("\n");
-      var diff = [];
-      var remEOFNL = false,
-          addEOFNL = false;
-
-      for (var i = (diffstr[0][0]=="I"?4:0); i < diffstr.length; i++) {
-        if(diffstr[i][0] == "@") {
-          var meh = diffstr[i].split(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/);
-          diff.unshift({
-            start:meh[3],
-            oldlength:meh[2],
-            oldlines:[],
-            newlength:meh[4],
-            newlines:[]
-          });
-        } else if(diffstr[i][0] == '+') {
-          diff[0].newlines.push(diffstr[i].substr(1));
-        } else if(diffstr[i][0] == '-') {
-          diff[0].oldlines.push(diffstr[i].substr(1));
-        } else if(diffstr[i][0] == ' ') {
-          diff[0].newlines.push(diffstr[i].substr(1));
-          diff[0].oldlines.push(diffstr[i].substr(1));
-        } else if(diffstr[i][0] == '\\') {
-          if (diffstr[i-1][0] == '+') {
-            remEOFNL = true;
-          } else if(diffstr[i-1][0] == '-') {
-            addEOFNL = true;
-          }
-        }
-      }
-
-      var str = oldStr.split("\n");
-      for (var i = diff.length - 1; i >= 0; i--) {
-        var d = diff[i];
-        for (var j = 0; j < d.oldlength; j++) {
-          if(str[d.start-1+j] != d.oldlines[j]) {
-            return false;
-          }
-        }
-        Array.prototype.splice.apply(str,[d.start-1,+d.oldlength].concat(d.newlines));
-      }
-
-      if (remEOFNL) {
-        while (!str[str.length-1]) {
-          str.pop();
-        }
-      } else if (addEOFNL) {
-        str.push('');
-      }
-      return str.join('\n');
-    },
-
-    convertChangesToXML: function(changes){
-      var ret = [];
-      for ( var i = 0; i < changes.length; i++) {
-        var change = changes[i];
-        if (change.added) {
-          ret.push("<ins>");
-        } else if (change.removed) {
-          ret.push("<del>");
-        }
-
-        ret.push(escapeHTML(change.value));
-
-        if (change.added) {
-          ret.push("</ins>");
-        } else if (change.removed) {
-          ret.push("</del>");
-        }
-      }
-      return ret.join("");
-    },
-
-    // See: http://code.google.com/p/google-diff-match-patch/wiki/API
-    convertChangesToDMP: function(changes){
-      var ret = [], change;
-      for ( var i = 0; i < changes.length; i++) {
-        change = changes[i];
-        ret.push([(change.added ? 1 : change.removed ? -1 : 0), change.value]);
-      }
-      return ret;
-    }
-  };
-})();
-
-if (typeof module !== "undefined") {
-    module.exports = JsDiff;
-}
diff --git a/all/jasmine-html.js b/all/jasmine-html.js
deleted file mode 100644
index 86688f3275..0000000000
--- a/all/jasmine-html.js
+++ /dev/null
@@ -1,683 +0,0 @@
-var jasmine = require("./jasmine");
-
-jasmine.HtmlReporterHelpers = {};
-
-jasmine.HtmlReporterHelpers.createDom = function(type, attrs, childrenVarArgs) {
-  var el = document.createElement(type);
-
-  for (var i = 2; i < arguments.length; i++) {
-    var child = arguments[i];
-
-    if (typeof child === 'string') {
-      el.appendChild(document.createTextNode(child));
-    } else {
-      if (child) {
-        el.appendChild(child);
-      }
-    }
-  }
-
-  for (var attr in attrs) {
-    if (attr == "className") {
-      el[attr] = attrs[attr];
-    } else {
-      el.setAttribute(attr, attrs[attr]);
-    }
-  }
-
-  return el;
-};
-
-jasmine.HtmlReporterHelpers.getSpecStatus = function(child) {
-  var results = child.results();
-  var status = results.passed() ? 'passed' : 'failed';
-  if (results.skipped) {
-    status = 'skipped';
-  }
-
-  return status;
-};
-
-jasmine.HtmlReporterHelpers.appendToSummary = function(child, childElement) {
-  var parentDiv = this.dom.summary;
-  var parentSuite = (typeof child.parentSuite == 'undefined') ? 'suite' : 'parentSuite';
-  var parent = child[parentSuite];
-
-  if (parent) {
-    if (typeof this.views.suites[parent.id] == 'undefined') {
-      this.views.suites[parent.id] = new jasmine.HtmlReporter.SuiteView(parent, this.dom, this.views);
-    }
-    parentDiv = this.views.suites[parent.id].element;
-  }
-
-  parentDiv.appendChild(childElement);
-};
-
-
-jasmine.HtmlReporterHelpers.addHelpers = function(ctor) {
-  for(var fn in jasmine.HtmlReporterHelpers) {
-    ctor.prototype[fn] = jasmine.HtmlReporterHelpers[fn];
-  }
-};
-
-jasmine.HtmlReporter = function(_doc) {
-  var self = this;
-  var doc = _doc || window.document;
-
-  var reporterView;
-
-  var dom = {};
-
-  // Jasmine Reporter Public Interface
-  self.logRunningSpecs = false;
-
-  self.reportRunnerStarting = function(runner) {
-    var specs = runner.specs() || [];
-
-    if (specs.length == 0) {
-      return;
-    }
-
-    createReporterDom(runner.env.versionString());
-    doc.body.appendChild(dom.reporter);
-    setExceptionHandling();
-
-    reporterView = new jasmine.HtmlReporter.ReporterView(dom);
-    reporterView.addSpecs(specs, self.specFilter);
-  };
-
-  self.reportRunnerResults = function(runner) {
-    reporterView && reporterView.complete();
-  };
-
-  self.reportSuiteResults = function(suite) {
-    reporterView.suiteComplete(suite);
-  };
-
-  self.reportSpecStarting = function(spec) {
-    if (self.logRunningSpecs) {
-      self.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
-    }
-  };
-
-  self.reportSpecResults = function(spec) {
-    reporterView.specComplete(spec);
-  };
-
-  self.log = function() {
-    var console = jasmine.getGlobal().console;
-    if (console && console.log) {
-      if (console.log.apply) {
-        console.log.apply(console, arguments);
-      } else {
-        console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
-      }
-    }
-  };
-
-  self.specFilter = function(spec) {
-    if (!focusedSpecName()) {
-      return true;
-    }
-
-    return spec.getFullName().indexOf(focusedSpecName()) === 0;
-  };
-
-  return self;
-
-  function focusedSpecName() {
-    var specName;
-
-    (function memoizeFocusedSpec() {
-      if (specName) {
-        return;
-      }
-
-      var paramMap = [];
-      var params = jasmine.HtmlReporter.parameters(doc);
-
-      for (var i = 0; i < params.length; i++) {
-        var p = params[i].split('=');
-        paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
-      }
-
-      specName = paramMap.spec;
-    })();
-
-    return specName;
-  }
-
-  function createReporterDom(version) {
-    dom.reporter = self.createDom('div', { id: 'HTMLReporter', className: 'jasmine_reporter' },
-      dom.banner = self.createDom('div', { className: 'banner' },
-        self.createDom('span', { className: 'title' }, "Jasmine "),
-        self.createDom('span', { className: 'version' }, version)),
-
-      dom.symbolSummary = self.createDom('ul', {className: 'symbolSummary'}),
-      dom.alert = self.createDom('div', {className: 'alert'},
-        self.createDom('span', { className: 'exceptions' },
-          self.createDom('label', { className: 'label', 'for': 'no_try_catch' }, 'No try/catch'),
-          self.createDom('input', { id: 'no_try_catch', type: 'checkbox' }))),
-      dom.results = self.createDom('div', {className: 'results'},
-        dom.summary = self.createDom('div', { className: 'summary' }),
-        dom.details = self.createDom('div', { id: 'details' }))
-    );
-  }
-
-  function noTryCatch() {
-    return window.location.search.match(/catch=false/);
-  }
-
-  function searchWithCatch() {
-    var params = jasmine.HtmlReporter.parameters(window.document);
-    var removed = false;
-    var i = 0;
-
-    while (!removed && i < params.length) {
-      if (params[i].match(/catch=/)) {
-        params.splice(i, 1);
-        removed = true;
-      }
-      i++;
-    }
-    if (jasmine.CATCH_EXCEPTIONS) {
-      params.push("catch=false");
-    }
-
-    return params.join("&");
-  }
-
-  function setExceptionHandling() {
-    var chxCatch = document.getElementById('no_try_catch');
-
-    if (noTryCatch()) {
-      chxCatch.setAttribute('checked', true);
-      jasmine.CATCH_EXCEPTIONS = false;
-    }
-    chxCatch.onclick = function() {
-      window.location.search = searchWithCatch();
-    };
-  }
-};
-jasmine.HtmlReporter.parameters = function(doc) {
-  var paramStr = doc.location.search.substring(1);
-  var params = [];
-
-  if (paramStr.length > 0) {
-    params = paramStr.split('&');
-  }
-  return params;
-}
-jasmine.HtmlReporter.sectionLink = function(sectionName) {
-  var link = '?';
-  var params = [];
-
-  if (sectionName) {
-    params.push('spec=' + encodeURIComponent(sectionName));
-  }
-  if (!jasmine.CATCH_EXCEPTIONS) {
-    params.push("catch=false");
-  }
-  if (params.length > 0) {
-    link += params.join("&");
-  }
-
-  return link;
-};
-jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter);
-jasmine.HtmlReporter.ReporterView = function(dom) {
-  this.startedAt = new Date();
-  this.runningSpecCount = 0;
-  this.completeSpecCount = 0;
-  this.passedCount = 0;
-  this.failedCount = 0;
-  this.skippedCount = 0;
-
-  this.createResultsMenu = function() {
-    this.resultsMenu = this.createDom('span', {className: 'resultsMenu bar'},
-      this.summaryMenuItem = this.createDom('a', {className: 'summaryMenuItem', href: "#"}, '0 specs'),
-      ' | ',
-      this.detailsMenuItem = this.createDom('a', {className: 'detailsMenuItem', href: "#"}, '0 failing'));
-
-    this.summaryMenuItem.onclick = function() {
-      dom.reporter.className = dom.reporter.className.replace(/ showDetails/g, '');
-    };
-
-    this.detailsMenuItem.onclick = function() {
-      showDetails();
-    };
-  };
-
-  this.addSpecs = function(specs, specFilter) {
-    this.totalSpecCount = specs.length;
-
-    this.views = {
-      specs: {},
-      suites: {}
-    };
-
-    for (var i = 0; i < specs.length; i++) {
-      var spec = specs[i];
-      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom, this.views);
-      if (specFilter(spec)) {
-        this.runningSpecCount++;
-      }
-    }
-  };
-
-  this.specComplete = function(spec) {
-    this.completeSpecCount++;
-
-    if (isUndefined(this.views.specs[spec.id])) {
-      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom);
-    }
-
-    var specView = this.views.specs[spec.id];
-
-    switch (specView.status()) {
-      case 'passed':
-        this.passedCount++;
-        break;
-
-      case 'failed':
-        this.failedCount++;
-        break;
-
-      case 'skipped':
-        this.skippedCount++;
-        break;
-    }
-
-    specView.refresh();
-    this.refresh();
-  };
-
-  this.suiteComplete = function(suite) {
-    var suiteView = this.views.suites[suite.id];
-    if (isUndefined(suiteView)) {
-      return;
-    }
-    suiteView.refresh();
-  };
-
-  this.refresh = function() {
-
-    if (isUndefined(this.resultsMenu)) {
-      this.createResultsMenu();
-    }
-
-    // currently running UI
-    if (isUndefined(this.runningAlert)) {
-      this.runningAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: "runningAlert bar" });
-      dom.alert.appendChild(this.runningAlert);
-    }
-    this.runningAlert.innerHTML = "Running " + this.completeSpecCount + " of " + specPluralizedFor(this.totalSpecCount);
-
-    // skipped specs UI
-    if (isUndefined(this.skippedAlert)) {
-      this.skippedAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: "skippedAlert bar" });
-    }
-
-    this.skippedAlert.innerHTML = "Skipping " + this.skippedCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
-
-    if (this.skippedCount === 1 && isDefined(dom.alert)) {
-      dom.alert.appendChild(this.skippedAlert);
-    }
-
-    // passing specs UI
-    if (isUndefined(this.passedAlert)) {
-      this.passedAlert = this.createDom('span', { href: jasmine.HtmlReporter.sectionLink(), className: "passingAlert bar" });
-    }
-    this.passedAlert.innerHTML = "Passing " + specPluralizedFor(this.passedCount);
-
-    // failing specs UI
-    if (isUndefined(this.failedAlert)) {
-      this.failedAlert = this.createDom('span', {href: "?", className: "failingAlert bar"});
-    }
-    this.failedAlert.innerHTML = "Failing " + specPluralizedFor(this.failedCount);
-
-    if (this.failedCount === 1 && isDefined(dom.alert)) {
-      dom.alert.appendChild(this.failedAlert);
-      dom.alert.appendChild(this.resultsMenu);
-    }
-
-    // summary info
-    this.summaryMenuItem.innerHTML = "" + specPluralizedFor(this.runningSpecCount);
-    this.detailsMenuItem.innerHTML = "" + this.failedCount + " failing";
-  };
-
-  this.complete = function() {
-    dom.alert.removeChild(this.runningAlert);
-
-    this.skippedAlert.innerHTML = "Ran " + this.runningSpecCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
-
-    if (this.failedCount === 0) {
-      dom.alert.appendChild(this.createDom('span', {className: 'passingAlert bar'}, "Passing " + specPluralizedFor(this.passedCount)));
-    } else {
-      showDetails();
-    }
-
-    dom.banner.appendChild(this.createDom('span', {className: 'duration'}, "finished in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s"));
-  };
-
-  return this;
-
-  function showDetails() {
-    if (dom.reporter.className.search(/showDetails/) === -1) {
-      dom.reporter.className += " showDetails";
-    }
-  }
-
-  function isUndefined(obj) {
-    return typeof obj === 'undefined';
-  }
-
-  function isDefined(obj) {
-    return !isUndefined(obj);
-  }
-
-  function specPluralizedFor(count) {
-    var str = count + " spec";
-    if (count > 1) {
-      str += "s"
-    }
-    return str;
-  }
-
-};
-
-jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.ReporterView);
-
-
-jasmine.HtmlReporter.SpecView = function(spec, dom, views) {
-  this.spec = spec;
-  this.dom = dom;
-  this.views = views;
-
-  this.symbol = this.createDom('li', { className: 'pending' });
-  this.dom.symbolSummary.appendChild(this.symbol);
-
-  this.summary = this.createDom('div', { className: 'specSummary' },
-    this.createDom('a', {
-      className: 'description',
-      href: jasmine.HtmlReporter.sectionLink(this.spec.getFullName()),
-      title: this.spec.getFullName()
-    }, this.spec.description)
-  );
-
-  this.detail = this.createDom('div', { className: 'specDetail' },
-      this.createDom('a', {
-        className: 'description',
-        href: '?spec=' + encodeURIComponent(this.spec.getFullName()),
-        title: this.spec.getFullName()
-      }, this.spec.getFullName())
-  );
-};
-
-jasmine.HtmlReporter.SpecView.prototype.status = function() {
-  return this.getSpecStatus(this.spec);
-};
-
-jasmine.HtmlReporter.SpecView.prototype.refresh = function() {
-  this.symbol.className = this.status();
-
-  switch (this.status()) {
-    case 'skipped':
-      break;
-
-    case 'passed':
-      this.appendSummaryToSuiteDiv();
-      break;
-
-    case 'failed':
-      this.appendSummaryToSuiteDiv();
-      this.appendFailureDetail();
-      break;
-  }
-};
-
-jasmine.HtmlReporter.SpecView.prototype.appendSummaryToSuiteDiv = function() {
-  this.summary.className += ' ' + this.status();
-  this.appendToSummary(this.spec, this.summary);
-};
-
-jasmine.HtmlReporter.SpecView.prototype.appendFailureDetail = function() {
-  this.detail.className += ' ' + this.status();
-
-  var resultItems = this.spec.results().getItems();
-  var messagesDiv = this.createDom('div', { className: 'messages' });
-
-  for (var i = 0; i < resultItems.length; i++) {
-    var result = resultItems[i];
-
-    if (result.type == 'log') {
-      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
-    } else if (result.type == 'expect' && result.passed && !result.passed()) {
-      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
-
-      if (result.trace.stack) {
-        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
-      }
-    }
-  }
-
-  if (messagesDiv.childNodes.length > 0) {
-    this.detail.appendChild(messagesDiv);
-    this.dom.details.appendChild(this.detail);
-  }
-};
-
-jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SpecView);jasmine.HtmlReporter.SuiteView = function(suite, dom, views) {
-  this.suite = suite;
-  this.dom = dom;
-  this.views = views;
-
-  this.element = this.createDom('div', { className: 'suite' },
-    this.createDom('a', { className: 'description', href: jasmine.HtmlReporter.sectionLink(this.suite.getFullName()) }, this.suite.description)
-  );
-
-  this.appendToSummary(this.suite, this.element);
-};
-
-jasmine.HtmlReporter.SuiteView.prototype.status = function() {
-  return this.getSpecStatus(this.suite);
-};
-
-jasmine.HtmlReporter.SuiteView.prototype.refresh = function() {
-  this.element.className += " " + this.status();
-};
-
-jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SuiteView);
-
-/* @deprecated Use jasmine.HtmlReporter instead
- */
-jasmine.TrivialReporter = function(doc) {
-  this.document = doc || document;
-  this.suiteDivs = {};
-  this.logRunningSpecs = false;
-};
-
-jasmine.TrivialReporter.prototype.createDom = function(type, attrs, childrenVarArgs) {
-  var el = document.createElement(type);
-
-  for (var i = 2; i < arguments.length; i++) {
-    var child = arguments[i];
-
-    if (typeof child === 'string') {
-      el.appendChild(document.createTextNode(child));
-    } else {
-      if (child) { el.appendChild(child); }
-    }
-  }
-
-  for (var attr in attrs) {
-    if (attr == "className") {
-      el[attr] = attrs[attr];
-    } else {
-      el.setAttribute(attr, attrs[attr]);
-    }
-  }
-
-  return el;
-};
-
-jasmine.TrivialReporter.prototype.reportRunnerStarting = function(runner) {
-  var showPassed, showSkipped;
-
-  this.outerDiv = this.createDom('div', { id: 'TrivialReporter', className: 'jasmine_reporter' },
-      this.createDom('div', { className: 'banner' },
-        this.createDom('div', { className: 'logo' },
-            this.createDom('span', { className: 'title' }, "Jasmine"),
-            this.createDom('span', { className: 'version' }, runner.env.versionString())),
-        this.createDom('div', { className: 'options' },
-            "Show ",
-            showPassed = this.createDom('input', { id: "__jasmine_TrivialReporter_showPassed__", type: 'checkbox' }),
-            this.createDom('label', { "for": "__jasmine_TrivialReporter_showPassed__" }, " passed "),
-            showSkipped = this.createDom('input', { id: "__jasmine_TrivialReporter_showSkipped__", type: 'checkbox' }),
-            this.createDom('label', { "for": "__jasmine_TrivialReporter_showSkipped__" }, " skipped")
-            )
-          ),
-
-      this.runnerDiv = this.createDom('div', { className: 'runner running' },
-          this.createDom('a', { className: 'run_spec', href: '?' }, "run all"),
-          this.runnerMessageSpan = this.createDom('span', {}, "Running..."),
-          this.finishedAtSpan = this.createDom('span', { className: 'finished-at' }, ""))
-      );
-
-  this.document.body.appendChild(this.outerDiv);
-
-  var suites = runner.suites();
-  for (var i = 0; i < suites.length; i++) {
-    var suite = suites[i];
-    var suiteDiv = this.createDom('div', { className: 'suite' },
-        this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, "run"),
-        this.createDom('a', { className: 'description', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, suite.description));
-    this.suiteDivs[suite.id] = suiteDiv;
-    var parentDiv = this.outerDiv;
-    if (suite.parentSuite) {
-      parentDiv = this.suiteDivs[suite.parentSuite.id];
-    }
-    parentDiv.appendChild(suiteDiv);
-  }
-
-  this.startedAt = new Date();
-
-  var self = this;
-  showPassed.onclick = function(evt) {
-    if (showPassed.checked) {
-      self.outerDiv.className += ' show-passed';
-    } else {
-      self.outerDiv.className = self.outerDiv.className.replace(/ show-passed/, '');
-    }
-  };
-
-  showSkipped.onclick = function(evt) {
-    if (showSkipped.checked) {
-      self.outerDiv.className += ' show-skipped';
-    } else {
-      self.outerDiv.className = self.outerDiv.className.replace(/ show-skipped/, '');
-    }
-  };
-};
-
-jasmine.TrivialReporter.prototype.reportRunnerResults = function(runner) {
-  var results = runner.results();
-  var className = (results.failedCount > 0) ? "runner failed" : "runner passed";
-  this.runnerDiv.setAttribute("class", className);
-  //do it twice for IE
-  this.runnerDiv.setAttribute("className", className);
-  var specs = runner.specs();
-  var specCount = 0;
-  for (var i = 0; i < specs.length; i++) {
-    if (this.specFilter(specs[i])) {
-      specCount++;
-    }
-  }
-  var message = "" + specCount + " spec" + (specCount == 1 ? "" : "s" ) + ", " + results.failedCount + " failure" + ((results.failedCount == 1) ? "" : "s");
-  message += " in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s";
-  this.runnerMessageSpan.replaceChild(this.createDom('a', { className: 'description', href: '?'}, message), this.runnerMessageSpan.firstChild);
-
-  this.finishedAtSpan.appendChild(document.createTextNode("Finished at " + new Date().toString()));
-};
-
-jasmine.TrivialReporter.prototype.reportSuiteResults = function(suite) {
-  var results = suite.results();
-  var status = results.passed() ? 'passed' : 'failed';
-  if (results.totalCount === 0) { // todo: change this to check results.skipped
-    status = 'skipped';
-  }
-  this.suiteDivs[suite.id].className += " " + status;
-};
-
-jasmine.TrivialReporter.prototype.reportSpecStarting = function(spec) {
-  if (this.logRunningSpecs) {
-    this.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
-  }
-};
-
-jasmine.TrivialReporter.prototype.reportSpecResults = function(spec) {
-  var results = spec.results();
-  var status = results.passed() ? 'passed' : 'failed';
-  if (results.skipped) {
-    status = 'skipped';
-  }
-  var specDiv = this.createDom('div', { className: 'spec '  + status },
-      this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(spec.getFullName()) }, "run"),
-      this.createDom('a', {
-        className: 'description',
-        href: '?spec=' + encodeURIComponent(spec.getFullName()),
-        title: spec.getFullName()
-      }, spec.description));
-
-
-  var resultItems = results.getItems();
-  var messagesDiv = this.createDom('div', { className: 'messages' });
-  for (var i = 0; i < resultItems.length; i++) {
-    var result = resultItems[i];
-
-    if (result.type == 'log') {
-      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
-    } else if (result.type == 'expect' && result.passed && !result.passed()) {
-      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
-
-      if (result.trace.stack) {
-        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
-      }
-    }
-  }
-
-  if (messagesDiv.childNodes.length > 0) {
-    specDiv.appendChild(messagesDiv);
-  }
-
-  this.suiteDivs[spec.suite.id].appendChild(specDiv);
-};
-
-jasmine.TrivialReporter.prototype.log = function() {
-  var console = jasmine.getGlobal().console;
-  if (console && console.log) {
-    if (console.log.apply) {
-      console.log.apply(console, arguments);
-    } else {
-      console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
-    }
-  }
-};
-
-jasmine.TrivialReporter.prototype.getLocation = function() {
-  return this.document.location;
-};
-
-jasmine.TrivialReporter.prototype.specFilter = function(spec) {
-  var paramMap = {};
-  var params = this.getLocation().search.substring(1).split('&');
-  for (var i = 0; i < params.length; i++) {
-    var p = params[i].split('=');
-    paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
-  }
-
-  if (!paramMap.spec) {
-    return true;
-  }
-  return spec.getFullName().indexOf(paramMap.spec) === 0;
-};
diff --git a/all/jasmine-support.js b/all/jasmine-support.js
deleted file mode 100644
index d6d1e3ef3b..0000000000
--- a/all/jasmine-support.js
+++ /dev/null
@@ -1,127 +0,0 @@
-var jasmine = require("./jasmine");
-var spec = false; // TODO
-
-// Add some matcher for mock functions
-jasmine.getEnv().beforeEach(function() {
-  this.addMatchers({
-    toBeCalled: function() {
-      if (this.actual.mock === undefined) {
-        throw Error('toBeCalled() should be used on a mock function');
-      }
-      return this.actual.mock.calls.length !== 0;
-    },
-
-    lastCalledWith: function() {
-      if (this.actual.mock === undefined) {
-        throw Error('toBeCalled() should be used on a mock function');
-      }
-      var calls = this.actual.mock.calls;
-      var args = Array.prototype.slice.call(arguments);
-      return this.env.equals_(calls[calls.length - 1], args);
-    },
-
-    toBeCalledWith: function() {
-      if (this.actual.mock === undefined) {
-        throw Error('toBeCalled() should be used on a mock function');
-      }
-      var args = Array.prototype.slice.call(arguments);
-      return this.actual.mock.calls.some(function(call) {
-        return this.env.equals_(call, args);
-      }.bind(this));
-    }
-  });
-});
-
-var _it = jasmine.Env.prototype.it;
-var _xit = jasmine.Env.prototype.xit;
-jasmine.Env.prototype.it = function(desc, func) {
-  // If spec is provided, only run matching specs
-  if (!spec || desc.match(new RegExp(spec, 'i'))) {
-    return _it.call(this, desc, func);
-  } else {
-    return this.xit(desc, func);
-  }
-};
-jasmine.Env.prototype.xit = function(desc, func) {
-  if (typeof func == 'function') {
-    var matches = func.toString().match(/.*\W?expect\(/g);
-    if (matches) {
-      this.reporter.subReporters_[0].skipCount += matches.length;
-      this.reporter.subReporters_[0].totalCount += matches.length;
-    }
-  }
-  return _xit.call(this, desc, func);
-}
-
-// Mainline Jasmine sets __Jasmine_been_here_before__ on each object to detect
-// cycles, but that doesn't work on frozen objects so we use a WeakMap instead.
-// We can only do this if if WeakMap is available, but if WeakMap is
-// unavailable, then objects probably can't be frozen anyway.
-
-if (typeof WeakMap !== "undefined") {
-  var _comparedObjects = new WeakMap;
-
-  jasmine.Env.prototype.compareObjects_ =
-  function(a, b, mismatchKeys, mismatchValues) {
-    if (_comparedObjects.get(a) === b && _comparedObjects.get(b) === a) {
-      return true;
-    }
-    var areArrays = jasmine.isArray_(a) && jasmine.isArray_(b);
-
-    _comparedObjects.set(a, b);
-    _comparedObjects.set(b, a);
-
-    var hasKey = function(obj, keyName) {
-      return obj != null && obj[keyName] !== jasmine.undefined;
-    };
-
-    for (var property in b) {
-      if (areArrays && typeof b[property] == 'function') {
-        continue;
-      }
-      if (!hasKey(a, property) && hasKey(b, property)) {
-        mismatchKeys.push(
-          "expected has key '" + property + "', but missing from actual."
-        );
-      }
-    }
-    for (property in a) {
-      if (areArrays && typeof a[property] == 'function') {
-        continue;
-      }
-      if (!hasKey(b, property) && hasKey(a, property)) {
-        mismatchKeys.push(
-          "expected missing key '" + property + "', but present in actual."
-        );
-      }
-    }
-    for (property in b) {
-      // The only different implementation from the original jasmine
-      if (areArrays &&
-          (typeof a[property] == 'function' ||
-           typeof b[property] == 'function')) {
-        continue;
-      }
-      if (!this.equals_(a[property], b[property], mismatchKeys, mismatchValues))
-      {
-        mismatchValues.push(
-          "'" + property + "' was '" + (b[property] ?
-            jasmine.util.htmlEscape(b[property].toString()) :
-            b[property]) +
-          "' in expected, but was '" + (a[property] ?
-            jasmine.util.htmlEscape(a[property].toString()) :
-            a[property]) + "' in actual."
-        );
-      }
-    }
-
-    if (areArrays &&
-        a.length != b.length) {
-      mismatchValues.push("arrays were not the same length");
-    }
-
-    _comparedObjects.delete(a);
-    _comparedObjects.delete(b);
-    return (mismatchKeys.length == 0 && mismatchValues.length == 0);
-  };
-}
diff --git a/all/jasmine.js b/all/jasmine.js
deleted file mode 100644
index 684c7cdf5b..0000000000
--- a/all/jasmine.js
+++ /dev/null
@@ -1,2597 +0,0 @@
-/**
- * Top level namespace for Jasmine, a lightweight JavaScript BDD/spec/testing framework.
- *
- * @namespace
- */
-var jasmine = {};
-exports = module.exports = jasmine;
-/**
- * @private
- */
-jasmine.unimplementedMethod_ = function() {
-  throw new Error("unimplemented method");
-};
-
-/**
- * Use <code>jasmine.undefined</code> instead of <code>undefined</code>, since <code>undefined</code> is just
- * a plain old variable and may be redefined by somebody else.
- *
- * @private
- */
-jasmine.undefined = jasmine.___undefined___;
-
-/**
- * Show diagnostic messages in the console if set to true
- *
- */
-jasmine.VERBOSE = false;
-
-/**
- * Default interval in milliseconds for event loop yields (e.g. to allow network activity or to refresh the screen with the HTML-based runner). Small values here may result in slow test running. Zero means no updates until all tests have completed.
- *
- */
-jasmine.DEFAULT_UPDATE_INTERVAL = 250;
-
-/**
- * Maximum levels of nesting that will be included when an object is pretty-printed
- */
-jasmine.MAX_PRETTY_PRINT_DEPTH = 40;
-
-/**
- * Default timeout interval in milliseconds for waitsFor() blocks.
- */
-jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000;
-
-/**
- * By default exceptions thrown in the context of a test are caught by jasmine so that it can run the remaining tests in the suite.
- * Set to false to let the exception bubble up in the browser.
- *
- */
-jasmine.CATCH_EXCEPTIONS = true;
-
-jasmine.getGlobal = function() {
-  function getGlobal() {
-    return this;
-  }
-
-  return getGlobal();
-};
-
-/**
- * Allows for bound functions to be compared.  Internal use only.
- *
- * @ignore
- * @private
- * @param base {Object} bound 'this' for the function
- * @param name {Function} function to find
- */
-jasmine.bindOriginal_ = function(base, name) {
-  var original = base[name];
-  if (original.apply) {
-    return function() {
-      return original.apply(base, arguments);
-    };
-  } else {
-    // IE support
-    return jasmine.getGlobal()[name];
-  }
-};
-
-jasmine.setTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'setTimeout');
-jasmine.clearTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearTimeout');
-jasmine.setInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'setInterval');
-jasmine.clearInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearInterval');
-
-jasmine.MessageResult = function(values) {
-  this.type = 'log';
-  this.values = values;
-  this.trace = new Error(); // todo: test better
-};
-
-jasmine.MessageResult.prototype.toString = function() {
-  var text = "";
-  for (var i = 0; i < this.values.length; i++) {
-    if (i > 0) text += " ";
-    if (jasmine.isString_(this.values[i])) {
-      text += this.values[i];
-    } else {
-      text += jasmine.pp(this.values[i]);
-    }
-  }
-  return text;
-};
-
-jasmine.ExpectationResult = function(params) {
-  this.type = 'expect';
-  this.matcherName = params.matcherName;
-  this.passed_ = params.passed;
-  this.expected = params.expected;
-  this.actual = params.actual;
-  this.message = this.passed_ ? 'Passed.' : params.message;
-
-  var trace = (params.trace || new Error(this.message));
-  this.trace = this.passed_ ? '' : trace;
-};
-
-jasmine.ExpectationResult.prototype.toString = function () {
-  return this.message;
-};
-
-jasmine.ExpectationResult.prototype.passed = function () {
-  return this.passed_;
-};
-
-/**
- * Getter for the Jasmine environment. Ensures one gets created
- */
-jasmine.getEnv = function() {
-  var env = jasmine.currentEnv_ = jasmine.currentEnv_ || new jasmine.Env();
-  return env;
-};
-
-/**
- * @ignore
- * @private
- * @param value
- * @returns {Boolean}
- */
-jasmine.isArray_ = function(value) {
-  return jasmine.isA_("Array", value);
-};
-
-/**
- * @ignore
- * @private
- * @param value
- * @returns {Boolean}
- */
-jasmine.isString_ = function(value) {
-  return jasmine.isA_("String", value);
-};
-
-/**
- * @ignore
- * @private
- * @param value
- * @returns {Boolean}
- */
-jasmine.isNumber_ = function(value) {
-  return jasmine.isA_("Number", value);
-};
-
-/**
- * @ignore
- * @private
- * @param {String} typeName
- * @param value
- * @returns {Boolean}
- */
-jasmine.isA_ = function(typeName, value) {
-  return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';
-};
-
-/**
- * Pretty printer for expecations.  Takes any object and turns it into a human-readable string.
- *
- * @param value {Object} an object to be outputted
- * @returns {String}
- */
-jasmine.pp = function(value) {
-  var stringPrettyPrinter = new jasmine.StringPrettyPrinter();
-  stringPrettyPrinter.format(value);
-  return stringPrettyPrinter.string;
-};
-
-/**
- * Returns true if the object is a DOM Node.
- *
- * @param {Object} obj object to check
- * @returns {Boolean}
- */
-jasmine.isDomNode = function(obj) {
-  return obj.nodeType > 0;
-};
-
-/**
- * Returns a matchable 'generic' object of the class type.  For use in expecations of type when values don't matter.
- *
- * @example
- * // don't care about which function is passed in, as long as it's a function
- * expect(mySpy).toHaveBeenCalledWith(jasmine.any(Function));
- *
- * @param {Class} clazz
- * @returns matchable object of the type clazz
- */
-jasmine.any = function(clazz) {
-  return new jasmine.Matchers.Any(clazz);
-};
-
-/**
- * Returns a matchable subset of a JSON object. For use in expectations when you don't care about all of the
- * attributes on the object.
- *
- * @example
- * // don't care about any other attributes than foo.
- * expect(mySpy).toHaveBeenCalledWith(jasmine.objectContaining({foo: "bar"});
- *
- * @param sample {Object} sample
- * @returns matchable object for the sample
- */
-jasmine.objectContaining = function (sample) {
-    return new jasmine.Matchers.ObjectContaining(sample);
-};
-
-/**
- * Jasmine Spies are test doubles that can act as stubs, spies, fakes or when used in an expecation, mocks.
- *
- * Spies should be created in test setup, before expectations.  They can then be checked, using the standard Jasmine
- * expectation syntax. Spies can be checked if they were called or not and what the calling params were.
- *
- * A Spy has the following fields: wasCalled, callCount, mostRecentCall, and argsForCall (see docs).
- *
- * Spies are torn down at the end of every spec.
- *
- * Note: Do <b>not</b> call new jasmine.Spy() directly - a spy must be created using spyOn, jasmine.createSpy or jasmine.createSpyObj.
- *
- * @example
- * // a stub
- * var myStub = jasmine.createSpy('myStub');  // can be used anywhere
- *
- * // spy example
- * var foo = {
- *   not: function(bool) { return !bool; }
- * }
- *
- * // actual foo.not will not be called, execution stops
- * spyOn(foo, 'not');
-
- // foo.not spied upon, execution will continue to implementation
- * spyOn(foo, 'not').andCallThrough();
- *
- * // fake example
- * var foo = {
- *   not: function(bool) { return !bool; }
- * }
- *
- * // foo.not(val) will return val
- * spyOn(foo, 'not').andCallFake(function(value) {return value;});
- *
- * // mock example
- * foo.not(7 == 7);
- * expect(foo.not).toHaveBeenCalled();
- * expect(foo.not).toHaveBeenCalledWith(true);
- *
- * @constructor
- * @see spyOn, jasmine.createSpy, jasmine.createSpyObj
- * @param {String} name
- */
-jasmine.Spy = function(name) {
-  /**
-   * The name of the spy, if provided.
-   */
-  this.identity = name || 'unknown';
-  /**
-   *  Is this Object a spy?
-   */
-  this.isSpy = true;
-  /**
-   * The actual function this spy stubs.
-   */
-  this.plan = function() {
-  };
-  /**
-   * Tracking of the most recent call to the spy.
-   * @example
-   * var mySpy = jasmine.createSpy('foo');
-   * mySpy(1, 2);
-   * mySpy.mostRecentCall.args = [1, 2];
-   */
-  this.mostRecentCall = {};
-
-  /**
-   * Holds arguments for each call to the spy, indexed by call count
-   * @example
-   * var mySpy = jasmine.createSpy('foo');
-   * mySpy(1, 2);
-   * mySpy(7, 8);
-   * mySpy.mostRecentCall.args = [7, 8];
-   * mySpy.argsForCall[0] = [1, 2];
-   * mySpy.argsForCall[1] = [7, 8];
-   */
-  this.argsForCall = [];
-  this.calls = [];
-};
-
-/**
- * Tells a spy to call through to the actual implemenatation.
- *
- * @example
- * var foo = {
- *   bar: function() { // do some stuff }
- * }
- *
- * // defining a spy on an existing property: foo.bar
- * spyOn(foo, 'bar').andCallThrough();
- */
-jasmine.Spy.prototype.andCallThrough = function() {
-  this.plan = this.originalValue;
-  return this;
-};
-
-/**
- * For setting the return value of a spy.
- *
- * @example
- * // defining a spy from scratch: foo() returns 'baz'
- * var foo = jasmine.createSpy('spy on foo').andReturn('baz');
- *
- * // defining a spy on an existing property: foo.bar() returns 'baz'
- * spyOn(foo, 'bar').andReturn('baz');
- *
- * @param {Object} value
- */
-jasmine.Spy.prototype.andReturn = function(value) {
-  this.plan = function() {
-    return value;
-  };
-  return this;
-};
-
-/**
- * For throwing an exception when a spy is called.
- *
- * @example
- * // defining a spy from scratch: foo() throws an exception w/ message 'ouch'
- * var foo = jasmine.createSpy('spy on foo').andThrow('baz');
- *
- * // defining a spy on an existing property: foo.bar() throws an exception w/ message 'ouch'
- * spyOn(foo, 'bar').andThrow('baz');
- *
- * @param {String} exceptionMsg
- */
-jasmine.Spy.prototype.andThrow = function(exceptionMsg) {
-  this.plan = function() {
-    throw exceptionMsg;
-  };
-  return this;
-};
-
-/**
- * Calls an alternate implementation when a spy is called.
- *
- * @example
- * var baz = function() {
- *   // do some stuff, return something
- * }
- * // defining a spy from scratch: foo() calls the function baz
- * var foo = jasmine.createSpy('spy on foo').andCall(baz);
- *
- * // defining a spy on an existing property: foo.bar() calls an anonymnous function
- * spyOn(foo, 'bar').andCall(function() { return 'baz';} );
- *
- * @param {Function} fakeFunc
- */
-jasmine.Spy.prototype.andCallFake = function(fakeFunc) {
-  this.plan = fakeFunc;
-  return this;
-};
-
-/**
- * Resets all of a spy's the tracking variables so that it can be used again.
- *
- * @example
- * spyOn(foo, 'bar');
- *
- * foo.bar();
- *
- * expect(foo.bar.callCount).toEqual(1);
- *
- * foo.bar.reset();
- *
- * expect(foo.bar.callCount).toEqual(0);
- */
-jasmine.Spy.prototype.reset = function() {
-  this.wasCalled = false;
-  this.callCount = 0;
-  this.argsForCall = [];
-  this.calls = [];
-  this.mostRecentCall = {};
-};
-
-jasmine.createSpy = function(name) {
-
-  var spyObj = function() {
-    spyObj.wasCalled = true;
-    spyObj.callCount++;
-    var args = jasmine.util.argsToArray(arguments);
-    spyObj.mostRecentCall.object = this;
-    spyObj.mostRecentCall.args = args;
-    spyObj.argsForCall.push(args);
-    spyObj.calls.push({object: this, args: args});
-    return spyObj.plan.apply(this, arguments);
-  };
-
-  var spy = new jasmine.Spy(name);
-
-  for (var prop in spy) {
-    spyObj[prop] = spy[prop];
-  }
-
-  spyObj.reset();
-
-  return spyObj;
-};
-
-/**
- * Determines whether an object is a spy.
- *
- * @param {jasmine.Spy|Object} putativeSpy
- * @returns {Boolean}
- */
-jasmine.isSpy = function(putativeSpy) {
-  return putativeSpy && putativeSpy.isSpy;
-};
-
-/**
- * Creates a more complicated spy: an Object that has every property a function that is a spy.  Used for stubbing something
- * large in one call.
- *
- * @param {String} baseName name of spy class
- * @param {Array} methodNames array of names of methods to make spies
- */
-jasmine.createSpyObj = function(baseName, methodNames) {
-  if (!jasmine.isArray_(methodNames) || methodNames.length === 0) {
-    throw new Error('createSpyObj requires a non-empty array of method names to create spies for');
-  }
-  var obj = {};
-  for (var i = 0; i < methodNames.length; i++) {
-    obj[methodNames[i]] = jasmine.createSpy(baseName + '.' + methodNames[i]);
-  }
-  return obj;
-};
-
-/**
- * All parameters are pretty-printed and concatenated together, then written to the current spec's output.
- *
- * Be careful not to leave calls to <code>jasmine.log</code> in production code.
- */
-jasmine.log = function() {
-  var spec = jasmine.getEnv().currentSpec;
-  spec.log.apply(spec, arguments);
-};
-
-/**
- * Function that installs a spy on an existing object's method name.  Used within a Spec to create a spy.
- *
- * @example
- * // spy example
- * var foo = {
- *   not: function(bool) { return !bool; }
- * }
- * spyOn(foo, 'not'); // actual foo.not will not be called, execution stops
- *
- * @see jasmine.createSpy
- * @param obj
- * @param methodName
- * @return {jasmine.Spy} a Jasmine spy that can be chained with all spy methods
- */
-var spyOn = function(obj, methodName) {
-  return jasmine.getEnv().currentSpec.spyOn(obj, methodName);
-};
-exports.spyOn = spyOn;
-
-/**
- * Creates a Jasmine spec that will be added to the current suite.
- *
- * // TODO: pending tests
- *
- * @example
- * it('should be true', function() {
- *   expect(true).toEqual(true);
- * });
- *
- * @param {String} desc description of this specification
- * @param {Function} func defines the preconditions and expectations of the spec
- */
-var it = function(desc, func) {
-  return jasmine.getEnv().it(desc, func);
-};
-exports.it = it;
-
-/**
- * Creates a <em>disabled</em> Jasmine spec.
- *
- * A convenience method that allows existing specs to be disabled temporarily during development.
- *
- * @param {String} desc description of this specification
- * @param {Function} func defines the preconditions and expectations of the spec
- */
-var xit = function(desc, func) {
-  return jasmine.getEnv().xit(desc, func);
-};
-exports.xit = xit;
-
-/**
- * Starts a chain for a Jasmine expectation.
- *
- * It is passed an Object that is the actual value and should chain to one of the many
- * jasmine.Matchers functions.
- *
- * @param {Object} actual Actual value to test against and expected value
- * @return {jasmine.Matchers}
- */
-var expect = function(actual) {
-  return jasmine.getEnv().currentSpec.expect(actual);
-};
-exports.expect = expect;
-
-/**
- * Defines part of a jasmine spec.  Used in cominbination with waits or waitsFor in asynchrnous specs.
- *
- * @param {Function} func Function that defines part of a jasmine spec.
- */
-var runs = function(func) {
-  jasmine.getEnv().currentSpec.runs(func);
-};
-exports.runs = runs;
-
-/**
- * Waits a fixed time period before moving to the next block.
- *
- * @deprecated Use waitsFor() instead
- * @param {Number} timeout milliseconds to wait
- */
-var waits = function(timeout) {
-  jasmine.getEnv().currentSpec.waits(timeout);
-};
-exports.waits = waits;
-
-/**
- * Waits for the latchFunction to return true before proceeding to the next block.
- *
- * @param {Function} latchFunction
- * @param {String} optional_timeoutMessage
- * @param {Number} optional_timeout
- */
-var waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
-  jasmine.getEnv().currentSpec.waitsFor.apply(jasmine.getEnv().currentSpec, arguments);
-};
-exports.waitsFor = waitsFor;
-
-/**
- * A function that is called before each spec in a suite.
- *
- * Used for spec setup, including validating assumptions.
- *
- * @param {Function} beforeEachFunction
- */
-var beforeEach = function(beforeEachFunction) {
-  jasmine.getEnv().beforeEach(beforeEachFunction);
-};
-exports.beforeEach = beforeEach;
-
-/**
- * A function that is called after each spec in a suite.
- *
- * Used for restoring any state that is hijacked during spec execution.
- *
- * @param {Function} afterEachFunction
- */
-var afterEach = function(afterEachFunction) {
-  jasmine.getEnv().afterEach(afterEachFunction);
-};
-exports.afterEach = afterEach;
-
-/**
- * Defines a suite of specifications.
- *
- * Stores the description and all defined specs in the Jasmine environment as one suite of specs. Variables declared
- * are accessible by calls to beforeEach, it, and afterEach. Describe blocks can be nested, allowing for specialization
- * of setup in some tests.
- *
- * @example
- * // TODO: a simple suite
- *
- * // TODO: a simple suite with a nested describe block
- *
- * @param {String} description A string, usually the class under test.
- * @param {Function} specDefinitions function that defines several specs.
- */
-var describe = function(description, specDefinitions) {
-  return jasmine.getEnv().describe(description, specDefinitions);
-};
-exports.describe = describe;
-
-/**
- * Disables a suite of specifications.  Used to disable some suites in a file, or files, temporarily during development.
- *
- * @param {String} description A string, usually the class under test.
- * @param {Function} specDefinitions function that defines several specs.
- */
-var xdescribe = function(description, specDefinitions) {
-  return jasmine.getEnv().xdescribe(description, specDefinitions);
-};
-exports.xdescribe = xdescribe;
-
-
-// Provide the XMLHttpRequest class for IE 5.x-6.x:
-jasmine.XmlHttpRequest = (typeof XMLHttpRequest == "undefined") ? function() {
-  function tryIt(f) {
-    try {
-      return f();
-    } catch(e) {
-    }
-    return null;
-  }
-
-  var xhr = tryIt(function() {
-    return new ActiveXObject("Msxml2.XMLHTTP.6.0");
-  }) ||
-    tryIt(function() {
-      return new ActiveXObject("Msxml2.XMLHTTP.3.0");
-    }) ||
-    tryIt(function() {
-      return new ActiveXObject("Msxml2.XMLHTTP");
-    }) ||
-    tryIt(function() {
-      return new ActiveXObject("Microsoft.XMLHTTP");
-    });
-
-  if (!xhr) throw new Error("This browser does not support XMLHttpRequest.");
-
-  return xhr;
-} : XMLHttpRequest;
-/**
- * @namespace
- */
-jasmine.util = {};
-
-/**
- * Declare that a child class inherit it's prototype from the parent class.
- *
- * @private
- * @param {Function} childClass
- * @param {Function} parentClass
- */
-jasmine.util.inherit = function(childClass, parentClass) {
-  /**
-   * @private
-   */
-  var subclass = function() {
-  };
-  subclass.prototype = parentClass.prototype;
-  childClass.prototype = new subclass();
-};
-
-jasmine.util.formatException = function(e) {
-  var lineNumber;
-  if (e.line) {
-    lineNumber = e.line;
-  }
-  else if (e.lineNumber) {
-    lineNumber = e.lineNumber;
-  }
-
-  var file;
-
-  if (e.sourceURL) {
-    file = e.sourceURL;
-  }
-  else if (e.fileName) {
-    file = e.fileName;
-  }
-
-  var message = (e.name && e.message) ? (e.name + ': ' + e.message) : e.toString();
-
-  if (file && lineNumber) {
-    message += ' in ' + file + ' (line ' + lineNumber + ')';
-  }
-
-  return message;
-};
-
-jasmine.util.htmlEscape = function(str) {
-  if (!str) return str;
-  return str.replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;');
-};
-
-jasmine.util.argsToArray = function(args) {
-  var arrayOfArgs = [];
-  for (var i = 0; i < args.length; i++) arrayOfArgs.push(args[i]);
-  return arrayOfArgs;
-};
-
-jasmine.util.extend = function(destination, source) {
-  for (var property in source) destination[property] = source[property];
-  return destination;
-};
-
-/**
- * Environment for Jasmine
- *
- * @constructor
- */
-jasmine.Env = function() {
-  this.currentSpec = null;
-  this.currentSuite = null;
-  this.currentRunner_ = new jasmine.Runner(this);
-
-  this.reporter = new jasmine.MultiReporter();
-
-  this.updateInterval = jasmine.DEFAULT_UPDATE_INTERVAL;
-  this.defaultTimeoutInterval = jasmine.DEFAULT_TIMEOUT_INTERVAL;
-  this.lastUpdate = 0;
-  this.specFilter = function() {
-    return true;
-  };
-
-  this.nextSpecId_ = 0;
-  this.nextSuiteId_ = 0;
-  this.equalityTesters_ = [];
-
-  // wrap matchers
-  this.matchersClass = function() {
-    jasmine.Matchers.apply(this, arguments);
-  };
-  jasmine.util.inherit(this.matchersClass, jasmine.Matchers);
-
-  jasmine.Matchers.wrapInto_(jasmine.Matchers.prototype, this.matchersClass);
-};
-
-
-jasmine.Env.prototype.setTimeout = jasmine.setTimeout;
-jasmine.Env.prototype.clearTimeout = jasmine.clearTimeout;
-jasmine.Env.prototype.setInterval = jasmine.setInterval;
-jasmine.Env.prototype.clearInterval = jasmine.clearInterval;
-
-/**
- * @returns an object containing jasmine version build info, if set.
- */
-jasmine.Env.prototype.version = function () {
-  if (jasmine.version_) {
-    return jasmine.version_;
-  } else {
-    throw new Error('Version not set');
-  }
-};
-
-/**
- * @returns string containing jasmine version build info, if set.
- */
-jasmine.Env.prototype.versionString = function() {
-  if (!jasmine.version_) {
-    return "version unknown";
-  }
-
-  var version = this.version();
-  var versionString = version.major + "." + version.minor + "." + version.build;
-  if (version.release_candidate) {
-    versionString += ".rc" + version.release_candidate;
-  }
-  versionString += " revision " + version.revision;
-  return versionString;
-};
-
-/**
- * @returns a sequential integer starting at 0
- */
-jasmine.Env.prototype.nextSpecId = function () {
-  return this.nextSpecId_++;
-};
-
-/**
- * @returns a sequential integer starting at 0
- */
-jasmine.Env.prototype.nextSuiteId = function () {
-  return this.nextSuiteId_++;
-};
-
-/**
- * Register a reporter to receive status updates from Jasmine.
- * @param {jasmine.Reporter} reporter An object which will receive status updates.
- */
-jasmine.Env.prototype.addReporter = function(reporter) {
-  this.reporter.addReporter(reporter);
-};
-
-jasmine.Env.prototype.execute = function() {
-  this.currentRunner_.execute();
-};
-
-jasmine.Env.prototype.describe = function(description, specDefinitions) {
-  var suite = new jasmine.Suite(this, description, specDefinitions, this.currentSuite);
-
-  var parentSuite = this.currentSuite;
-  if (parentSuite) {
-    parentSuite.add(suite);
-  } else {
-    this.currentRunner_.add(suite);
-  }
-
-  this.currentSuite = suite;
-
-  var declarationError = null;
-  try {
-    specDefinitions.call(suite);
-  } catch(e) {
-    declarationError = e;
-  }
-
-  if (declarationError) {
-    this.it("encountered a declaration exception", function() {
-      throw declarationError;
-    });
-  }
-
-  this.currentSuite = parentSuite;
-
-  return suite;
-};
-
-jasmine.Env.prototype.beforeEach = function(beforeEachFunction) {
-  if (this.currentSuite) {
-    this.currentSuite.beforeEach(beforeEachFunction);
-  } else {
-    this.currentRunner_.beforeEach(beforeEachFunction);
-  }
-};
-
-jasmine.Env.prototype.currentRunner = function () {
-  return this.currentRunner_;
-};
-
-jasmine.Env.prototype.afterEach = function(afterEachFunction) {
-  if (this.currentSuite) {
-    this.currentSuite.afterEach(afterEachFunction);
-  } else {
-    this.currentRunner_.afterEach(afterEachFunction);
-  }
-
-};
-
-jasmine.Env.prototype.xdescribe = function(desc, specDefinitions) {
-  return {
-    execute: function() {
-    }
-  };
-};
-
-jasmine.Env.prototype.it = function(description, func) {
-  var spec = new jasmine.Spec(this, this.currentSuite, description);
-  this.currentSuite.add(spec);
-  this.currentSpec = spec;
-
-  if (func) {
-    spec.runs(func);
-  }
-
-  return spec;
-};
-
-jasmine.Env.prototype.xit = function(desc, func) {
-  var spec = this.it(desc, func);
-  spec.results_.skipped = true;
-  spec.runs = function() {};
-  return spec;
-};
-
-jasmine.Env.prototype.compareRegExps_ = function(a, b, mismatchKeys, mismatchValues) {
-  if (a.source != b.source)
-    mismatchValues.push("expected pattern /" + b.source + "/ is not equal to the pattern /" + a.source + "/");
-
-  if (a.ignoreCase != b.ignoreCase)
-    mismatchValues.push("expected modifier i was" + (b.ignoreCase ? " " : " not ") + "set and does not equal the origin modifier");
-
-  if (a.global != b.global)
-    mismatchValues.push("expected modifier g was" + (b.global ? " " : " not ") + "set and does not equal the origin modifier");
-
-  if (a.multiline != b.multiline)
-    mismatchValues.push("expected modifier m was" + (b.multiline ? " " : " not ") + "set and does not equal the origin modifier");
-
-  if (a.sticky != b.sticky)
-    mismatchValues.push("expected modifier y was" + (b.sticky ? " " : " not ") + "set and does not equal the origin modifier");
-
-  return (mismatchValues.length === 0);
-};
-
-jasmine.Env.prototype.compareObjects_ = function(a, b, mismatchKeys, mismatchValues) {
-  if (a.__Jasmine_been_here_before__ === b && b.__Jasmine_been_here_before__ === a) {
-    return true;
-  }
-
-  a.__Jasmine_been_here_before__ = b;
-  b.__Jasmine_been_here_before__ = a;
-
-  var hasKey = function(obj, keyName) {
-    return obj !== null && obj[keyName] !== jasmine.undefined;
-  };
-
-  for (var property in b) {
-    if (!hasKey(a, property) && hasKey(b, property)) {
-      mismatchKeys.push("expected has key '" + property + "', but missing from actual.");
-    }
-  }
-  for (property in a) {
-    if (!hasKey(b, property) && hasKey(a, property)) {
-      mismatchKeys.push("expected missing key '" + property + "', but present in actual.");
-    }
-  }
-  for (property in b) {
-    if (property == '__Jasmine_been_here_before__') continue;
-    if (!this.equals_(a[property], b[property], mismatchKeys, mismatchValues)) {
-      mismatchValues.push("'" + property + "' was '" + (b[property] ? jasmine.util.htmlEscape(b[property].toString()) : b[property]) + "' in expected, but was '" + (a[property] ? jasmine.util.htmlEscape(a[property].toString()) : a[property]) + "' in actual.");
-    }
-  }
-
-  if (jasmine.isArray_(a) && jasmine.isArray_(b) && a.length != b.length) {
-    mismatchValues.push("arrays were not the same length");
-  }
-
-  delete a.__Jasmine_been_here_before__;
-  delete b.__Jasmine_been_here_before__;
-  return (mismatchKeys.length === 0 && mismatchValues.length === 0);
-};
-
-jasmine.Env.prototype.equals_ = function(a, b, mismatchKeys, mismatchValues) {
-  mismatchKeys = mismatchKeys || [];
-  mismatchValues = mismatchValues || [];
-
-  for (var i = 0; i < this.equalityTesters_.length; i++) {
-    var equalityTester = this.equalityTesters_[i];
-    var result = equalityTester(a, b, this, mismatchKeys, mismatchValues);
-    if (result !== jasmine.undefined) return result;
-  }
-
-  if (a === b) return true;
-
-  if (a === jasmine.undefined || a === null || b === jasmine.undefined || b === null) {
-    return (a == jasmine.undefined && b == jasmine.undefined);
-  }
-
-  if (jasmine.isDomNode(a) && jasmine.isDomNode(b)) {
-    return a === b;
-  }
-
-  if (a instanceof Date && b instanceof Date) {
-    return a.getTime() == b.getTime();
-  }
-
-  if (a.jasmineMatches) {
-    return a.jasmineMatches(b);
-  }
-
-  if (b.jasmineMatches) {
-    return b.jasmineMatches(a);
-  }
-
-  if (a instanceof jasmine.Matchers.ObjectContaining) {
-    return a.matches(b);
-  }
-
-  if (b instanceof jasmine.Matchers.ObjectContaining) {
-    return b.matches(a);
-  }
-
-  if (jasmine.isString_(a) && jasmine.isString_(b)) {
-    return (a == b);
-  }
-
-  if (jasmine.isNumber_(a) && jasmine.isNumber_(b)) {
-    return (a == b);
-  }
-
-  if (a instanceof RegExp && b instanceof RegExp) {
-    return this.compareRegExps_(a, b, mismatchKeys, mismatchValues);
-  }
-
-  if (typeof a === "object" && typeof b === "object") {
-    return this.compareObjects_(a, b, mismatchKeys, mismatchValues);
-  }
-
-  //Straight check
-  return (a === b);
-};
-
-jasmine.Env.prototype.contains_ = function(haystack, needle) {
-  if (jasmine.isArray_(haystack)) {
-    for (var i = 0; i < haystack.length; i++) {
-      if (this.equals_(haystack[i], needle)) return true;
-    }
-    return false;
-  }
-  return haystack.indexOf(needle) >= 0;
-};
-
-jasmine.Env.prototype.addEqualityTester = function(equalityTester) {
-  this.equalityTesters_.push(equalityTester);
-};
-/** No-op base class for Jasmine reporters.
- *
- * @constructor
- */
-jasmine.Reporter = function() {
-};
-
-//noinspection JSUnusedLocalSymbols
-jasmine.Reporter.prototype.reportRunnerStarting = function(runner) {
-};
-
-//noinspection JSUnusedLocalSymbols
-jasmine.Reporter.prototype.reportRunnerResults = function(runner) {
-};
-
-//noinspection JSUnusedLocalSymbols
-jasmine.Reporter.prototype.reportSuiteResults = function(suite) {
-};
-
-//noinspection JSUnusedLocalSymbols
-jasmine.Reporter.prototype.reportSpecStarting = function(spec) {
-};
-
-//noinspection JSUnusedLocalSymbols
-jasmine.Reporter.prototype.reportSpecResults = function(spec) {
-};
-
-//noinspection JSUnusedLocalSymbols
-jasmine.Reporter.prototype.log = function(str) {
-};
-
-/**
- * Blocks are functions with executable code that make up a spec.
- *
- * @constructor
- * @param {jasmine.Env} env
- * @param {Function} func
- * @param {jasmine.Spec} spec
- */
-jasmine.Block = function(env, func, spec) {
-  this.env = env;
-  this.func = func;
-  this.spec = spec;
-};
-
-jasmine.Block.prototype.execute = function(onComplete) {
-  if (!jasmine.CATCH_EXCEPTIONS) {
-    this.func.apply(this.spec);
-  }
-  else {
-    try {
-      this.func.apply(this.spec);
-    } catch (e) {
-      this.spec.fail(e);
-    }
-  }
-  onComplete();
-};
-/** JavaScript API reporter.
- *
- * @constructor
- */
-jasmine.JsApiReporter = function() {
-  this.started = false;
-  this.finished = false;
-  this.suites_ = [];
-  this.results_ = {};
-};
-
-jasmine.JsApiReporter.prototype.reportRunnerStarting = function(runner) {
-  this.started = true;
-  var suites = runner.topLevelSuites();
-  for (var i = 0; i < suites.length; i++) {
-    var suite = suites[i];
-    this.suites_.push(this.summarize_(suite));
-  }
-};
-
-jasmine.JsApiReporter.prototype.suites = function() {
-  return this.suites_;
-};
-
-jasmine.JsApiReporter.prototype.summarize_ = function(suiteOrSpec) {
-  var isSuite = suiteOrSpec instanceof jasmine.Suite;
-  var summary = {
-    id: suiteOrSpec.id,
-    name: suiteOrSpec.description,
-    type: isSuite ? 'suite' : 'spec',
-    children: []
-  };
-  
-  if (isSuite) {
-    var children = suiteOrSpec.children();
-    for (var i = 0; i < children.length; i++) {
-      summary.children.push(this.summarize_(children[i]));
-    }
-  }
-  return summary;
-};
-
-jasmine.JsApiReporter.prototype.results = function() {
-  return this.results_;
-};
-
-jasmine.JsApiReporter.prototype.resultsForSpec = function(specId) {
-  return this.results_[specId];
-};
-
-//noinspection JSUnusedLocalSymbols
-jasmine.JsApiReporter.prototype.reportRunnerResults = function(runner) {
-  this.finished = true;
-};
-
-//noinspection JSUnusedLocalSymbols
-jasmine.JsApiReporter.prototype.reportSuiteResults = function(suite) {
-};
-
-//noinspection JSUnusedLocalSymbols
-jasmine.JsApiReporter.prototype.reportSpecResults = function(spec) {
-  this.results_[spec.id] = {
-    messages: spec.results().getItems(),
-    result: spec.results().failedCount > 0 ? "failed" : "passed"
-  };
-};
-
-//noinspection JSUnusedLocalSymbols
-jasmine.JsApiReporter.prototype.log = function(str) {
-};
-
-jasmine.JsApiReporter.prototype.resultsForSpecs = function(specIds){
-  var results = {};
-  for (var i = 0; i < specIds.length; i++) {
-    var specId = specIds[i];
-    results[specId] = this.summarizeResult_(this.results_[specId]);
-  }
-  return results;
-};
-
-jasmine.JsApiReporter.prototype.summarizeResult_ = function(result){
-  var summaryMessages = [];
-  var messagesLength = result.messages.length;
-  for (var messageIndex = 0; messageIndex < messagesLength; messageIndex++) {
-    var resultMessage = result.messages[messageIndex];
-    summaryMessages.push({
-      text: resultMessage.type == 'log' ? resultMessage.toString() : jasmine.undefined,
-      passed: resultMessage.passed ? resultMessage.passed() : true,
-      type: resultMessage.type,
-      message: resultMessage.message,
-      trace: {
-        stack: resultMessage.passed && !resultMessage.passed() ? resultMessage.trace.stack : jasmine.undefined
-      }
-    });
-  }
-
-  return {
-    result : result.result,
-    messages : summaryMessages
-  };
-};
-
-/**
- * @constructor
- * @param {jasmine.Env} env
- * @param actual
- * @param {jasmine.Spec} spec
- */
-jasmine.Matchers = function(env, actual, spec, opt_isNot) {
-  this.env = env;
-  this.actual = actual;
-  this.spec = spec;
-  this.isNot = opt_isNot || false;
-  this.reportWasCalled_ = false;
-};
-
-// todo: @deprecated as of Jasmine 0.11, remove soon [xw]
-jasmine.Matchers.pp = function(str) {
-  throw new Error("jasmine.Matchers.pp() is no longer supported, please use jasmine.pp() instead!");
-};
-
-// todo: @deprecated Deprecated as of Jasmine 0.10. Rewrite your custom matchers to return true or false. [xw]
-jasmine.Matchers.prototype.report = function(result, failing_message, details) {
-  throw new Error("As of jasmine 0.11, custom matchers must be implemented differently -- please see jasmine docs");
-};
-
-jasmine.Matchers.wrapInto_ = function(prototype, matchersClass) {
-  for (var methodName in prototype) {
-    if (methodName == 'report') continue;
-    var orig = prototype[methodName];
-    matchersClass.prototype[methodName] = jasmine.Matchers.matcherFn_(methodName, orig);
-  }
-};
-
-jasmine.Matchers.matcherFn_ = function(matcherName, matcherFunction) {
-  return function() {
-    var matcherArgs = jasmine.util.argsToArray(arguments);
-    var result = matcherFunction.apply(this, arguments);
-
-    if (this.isNot) {
-      result = !result;
-    }
-
-    if (this.reportWasCalled_) return result;
-
-    var message;
-    if (!result) {
-      if (this.message) {
-        message = this.message.apply(this, arguments);
-        if (jasmine.isArray_(message)) {
-          message = message[this.isNot ? 1 : 0];
-        }
-      } else {
-        var englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) { return ' ' + s.toLowerCase(); });
-        message = "Expected " + jasmine.pp(this.actual) + (this.isNot ? " not " : " ") + englishyPredicate;
-        if (matcherArgs.length > 0) {
-          for (var i = 0; i < matcherArgs.length; i++) {
-            if (i > 0) message += ",";
-            message += " " + jasmine.pp(matcherArgs[i]);
-          }
-        }
-        message += ".";
-      }
-    }
-    var expectationResult = new jasmine.ExpectationResult({
-      matcherName: matcherName,
-      passed: result,
-      expected: matcherArgs.length > 1 ? matcherArgs : matcherArgs[0],
-      actual: this.actual,
-      message: message
-    });
-    this.spec.addMatcherResult(expectationResult);
-    return jasmine.undefined;
-  };
-};
-
-
-
-
-/**
- * toBe: compares the actual to the expected using ===
- * @param expected
- */
-jasmine.Matchers.prototype.toBe = function(expected) {
-  return this.actual === expected;
-};
-
-/**
- * toNotBe: compares the actual to the expected using !==
- * @param expected
- * @deprecated as of 1.0. Use not.toBe() instead.
- */
-jasmine.Matchers.prototype.toNotBe = function(expected) {
-  return this.actual !== expected;
-};
-
-/**
- * toEqual: compares the actual to the expected using common sense equality. Handles Objects, Arrays, etc.
- *
- * @param expected
- */
-jasmine.Matchers.prototype.toEqual = function(expected) {
-  return this.env.equals_(this.actual, expected);
-};
-
-/**
- * toNotEqual: compares the actual to the expected using the ! of jasmine.Matchers.toEqual
- * @param expected
- * @deprecated as of 1.0. Use not.toEqual() instead.
- */
-jasmine.Matchers.prototype.toNotEqual = function(expected) {
-  return !this.env.equals_(this.actual, expected);
-};
-
-/**
- * Matcher that compares the actual to the expected using a regular expression.  Constructs a RegExp, so takes
- * a pattern or a String.
- *
- * @param expected
- */
-jasmine.Matchers.prototype.toMatch = function(expected) {
-  return new RegExp(expected).test(this.actual);
-};
-
-/**
- * Matcher that compares the actual to the expected using the boolean inverse of jasmine.Matchers.toMatch
- * @param expected
- * @deprecated as of 1.0. Use not.toMatch() instead.
- */
-jasmine.Matchers.prototype.toNotMatch = function(expected) {
-  return !(new RegExp(expected).test(this.actual));
-};
-
-/**
- * Matcher that compares the actual to jasmine.undefined.
- */
-jasmine.Matchers.prototype.toBeDefined = function() {
-  return (this.actual !== jasmine.undefined);
-};
-
-/**
- * Matcher that compares the actual to jasmine.undefined.
- */
-jasmine.Matchers.prototype.toBeUndefined = function() {
-  return (this.actual === jasmine.undefined);
-};
-
-/**
- * Matcher that compares the actual to null.
- */
-jasmine.Matchers.prototype.toBeNull = function() {
-  return (this.actual === null);
-};
-
-/**
- * Matcher that compares the actual to NaN.
- */
-jasmine.Matchers.prototype.toBeNaN = function() {
-	this.message = function() {
-		return [ "Expected " + jasmine.pp(this.actual) + " to be NaN." ];
-	};
-
-	return (this.actual !== this.actual);
-};
-
-/**
- * Matcher that boolean not-nots the actual.
- */
-jasmine.Matchers.prototype.toBeTruthy = function() {
-  return !!this.actual;
-};
-
-
-/**
- * Matcher that boolean nots the actual.
- */
-jasmine.Matchers.prototype.toBeFalsy = function() {
-  return !this.actual;
-};
-
-
-/**
- * Matcher that checks to see if the actual, a Jasmine spy, was called.
- */
-jasmine.Matchers.prototype.toHaveBeenCalled = function() {
-  if (arguments.length > 0) {
-    throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
-  }
-
-  if (!jasmine.isSpy(this.actual)) {
-    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
-  }
-
-  this.message = function() {
-    return [
-      "Expected spy " + this.actual.identity + " to have been called.",
-      "Expected spy " + this.actual.identity + " not to have been called."
-    ];
-  };
-
-  return this.actual.wasCalled;
-};
-
-/** @deprecated Use expect(xxx).toHaveBeenCalled() instead */
-jasmine.Matchers.prototype.wasCalled = jasmine.Matchers.prototype.toHaveBeenCalled;
-
-/**
- * Matcher that checks to see if the actual, a Jasmine spy, was not called.
- *
- * @deprecated Use expect(xxx).not.toHaveBeenCalled() instead
- */
-jasmine.Matchers.prototype.wasNotCalled = function() {
-  if (arguments.length > 0) {
-    throw new Error('wasNotCalled does not take arguments');
-  }
-
-  if (!jasmine.isSpy(this.actual)) {
-    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
-  }
-
-  this.message = function() {
-    return [
-      "Expected spy " + this.actual.identity + " to not have been called.",
-      "Expected spy " + this.actual.identity + " to have been called."
-    ];
-  };
-
-  return !this.actual.wasCalled;
-};
-
-/**
- * Matcher that checks to see if the actual, a Jasmine spy, was called with a set of parameters.
- *
- * @example
- *
- */
-jasmine.Matchers.prototype.toHaveBeenCalledWith = function() {
-  var expectedArgs = jasmine.util.argsToArray(arguments);
-  if (!jasmine.isSpy(this.actual)) {
-    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
-  }
-  this.message = function() {
-    var invertedMessage = "Expected spy " + this.actual.identity + " not to have been called with " + jasmine.pp(expectedArgs) + " but it was.";
-    var positiveMessage = "";
-    if (this.actual.callCount === 0) {
-      positiveMessage = "Expected spy " + this.actual.identity + " to have been called with " + jasmine.pp(expectedArgs) + " but it was never called.";
-    } else {
-      positiveMessage = "Expected spy " + this.actual.identity + " to have been called with " + jasmine.pp(expectedArgs) + " but actual calls were " + jasmine.pp(this.actual.argsForCall).replace(/^\[ | \]$/g, '')
-    }
-    return [positiveMessage, invertedMessage];
-  };
-
-  return this.env.contains_(this.actual.argsForCall, expectedArgs);
-};
-
-/** @deprecated Use expect(xxx).toHaveBeenCalledWith() instead */
-jasmine.Matchers.prototype.wasCalledWith = jasmine.Matchers.prototype.toHaveBeenCalledWith;
-
-/** @deprecated Use expect(xxx).not.toHaveBeenCalledWith() instead */
-jasmine.Matchers.prototype.wasNotCalledWith = function() {
-  var expectedArgs = jasmine.util.argsToArray(arguments);
-  if (!jasmine.isSpy(this.actual)) {
-    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
-  }
-
-  this.message = function() {
-    return [
-      "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but it was",
-      "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but it was"
-    ];
-  };
-
-  return !this.env.contains_(this.actual.argsForCall, expectedArgs);
-};
-
-/**
- * Matcher that checks that the expected item is an element in the actual Array.
- *
- * @param {Object} expected
- */
-jasmine.Matchers.prototype.toContain = function(expected) {
-  return this.env.contains_(this.actual, expected);
-};
-
-/**
- * Matcher that checks that the expected item is NOT an element in the actual Array.
- *
- * @param {Object} expected
- * @deprecated as of 1.0. Use not.toContain() instead.
- */
-jasmine.Matchers.prototype.toNotContain = function(expected) {
-  return !this.env.contains_(this.actual, expected);
-};
-
-jasmine.Matchers.prototype.toBeLessThan = function(expected) {
-  return this.actual < expected;
-};
-
-jasmine.Matchers.prototype.toBeGreaterThan = function(expected) {
-  return this.actual > expected;
-};
-
-/**
- * Matcher that checks that the expected item is equal to the actual item
- * up to a given level of decimal precision (default 2).
- *
- * @param {Number} expected
- * @param {Number} precision, as number of decimal places
- */
-jasmine.Matchers.prototype.toBeCloseTo = function(expected, precision) {
-  if (!(precision === 0)) {
-    precision = precision || 2;
-  }
-  return Math.abs(expected - this.actual) < (Math.pow(10, -precision) / 2);
-};
-
-/**
- * Matcher that checks that the expected exception was thrown by the actual.
- *
- * @param {String} [expected]
- */
-jasmine.Matchers.prototype.toThrow = function(expected) {
-  var result = false;
-  var exception;
-  if (typeof this.actual != 'function') {
-    throw new Error('Actual is not a function');
-  }
-  try {
-    this.actual();
-  } catch (e) {
-    exception = e;
-  }
-  if (exception) {
-    result = (expected === jasmine.undefined || this.env.equals_(exception.message || exception, expected.message || expected));
-  }
-
-  var not = this.isNot ? "not " : "";
-
-  this.message = function() {
-    if (exception && (expected === jasmine.undefined || !this.env.equals_(exception.message || exception, expected.message || expected))) {
-      return ["Expected function " + not + "to throw", expected ? expected.message || expected : "an exception", ", but it threw", exception.message || exception].join(' ');
-    } else {
-      return "Expected function to throw an exception.";
-    }
-  };
-
-  return result;
-};
-
-jasmine.Matchers.Any = function(expectedClass) {
-  this.expectedClass = expectedClass;
-};
-
-jasmine.Matchers.Any.prototype.jasmineMatches = function(other) {
-  if (this.expectedClass == String) {
-    return typeof other == 'string' || other instanceof String;
-  }
-
-  if (this.expectedClass == Number) {
-    return typeof other == 'number' || other instanceof Number;
-  }
-
-  if (this.expectedClass == Function) {
-    return typeof other == 'function' || other instanceof Function;
-  }
-
-  if (this.expectedClass == Object) {
-    return typeof other == 'object';
-  }
-
-  return other instanceof this.expectedClass;
-};
-
-jasmine.Matchers.Any.prototype.jasmineToString = function() {
-  return '<jasmine.any(' + this.expectedClass + ')>';
-};
-
-jasmine.Matchers.ObjectContaining = function (sample) {
-  this.sample = sample;
-};
-
-jasmine.Matchers.ObjectContaining.prototype.jasmineMatches = function(other, mismatchKeys, mismatchValues) {
-  mismatchKeys = mismatchKeys || [];
-  mismatchValues = mismatchValues || [];
-
-  var env = jasmine.getEnv();
-
-  var hasKey = function(obj, keyName) {
-    return obj != null && obj[keyName] !== jasmine.undefined;
-  };
-
-  for (var property in this.sample) {
-    if (!hasKey(other, property) && hasKey(this.sample, property)) {
-      mismatchKeys.push("expected has key '" + property + "', but missing from actual.");
-    }
-    else if (!env.equals_(this.sample[property], other[property], mismatchKeys, mismatchValues)) {
-      mismatchValues.push("'" + property + "' was '" + (other[property] ? jasmine.util.htmlEscape(other[property].toString()) : other[property]) + "' in expected, but was '" + (this.sample[property] ? jasmine.util.htmlEscape(this.sample[property].toString()) : this.sample[property]) + "' in actual.");
-    }
-  }
-
-  return (mismatchKeys.length === 0 && mismatchValues.length === 0);
-};
-
-jasmine.Matchers.ObjectContaining.prototype.jasmineToString = function () {
-  return "<jasmine.objectContaining(" + jasmine.pp(this.sample) + ")>";
-};
-// Mock setTimeout, clearTimeout
-// Contributed by Pivotal Computer Systems, www.pivotalsf.com
-
-jasmine.FakeTimer = function() {
-  this.reset();
-
-  var self = this;
-  self.setTimeout = function(funcToCall, millis) {
-    self.timeoutsMade++;
-    self.scheduleFunction(self.timeoutsMade, funcToCall, millis, false);
-    return self.timeoutsMade;
-  };
-
-  self.setInterval = function(funcToCall, millis) {
-    self.timeoutsMade++;
-    self.scheduleFunction(self.timeoutsMade, funcToCall, millis, true);
-    return self.timeoutsMade;
-  };
-
-  self.clearTimeout = function(timeoutKey) {
-    self.scheduledFunctions[timeoutKey] = jasmine.undefined;
-  };
-
-  self.clearInterval = function(timeoutKey) {
-    self.scheduledFunctions[timeoutKey] = jasmine.undefined;
-  };
-
-};
-
-jasmine.FakeTimer.prototype.reset = function() {
-  this.timeoutsMade = 0;
-  this.scheduledFunctions = {};
-  this.nowMillis = 0;
-};
-
-jasmine.FakeTimer.prototype.tick = function(millis) {
-  var oldMillis = this.nowMillis;
-  var newMillis = oldMillis + millis;
-  this.runFunctionsWithinRange(oldMillis, newMillis);
-  this.nowMillis = newMillis;
-};
-
-jasmine.FakeTimer.prototype.runFunctionsWithinRange = function(oldMillis, nowMillis) {
-  var scheduledFunc;
-  var funcsToRun = [];
-  for (var timeoutKey in this.scheduledFunctions) {
-    scheduledFunc = this.scheduledFunctions[timeoutKey];
-    if (scheduledFunc != jasmine.undefined &&
-        scheduledFunc.runAtMillis >= oldMillis &&
-        scheduledFunc.runAtMillis <= nowMillis) {
-      funcsToRun.push(scheduledFunc);
-      this.scheduledFunctions[timeoutKey] = jasmine.undefined;
-    }
-  }
-
-  if (funcsToRun.length > 0) {
-    funcsToRun.sort(function(a, b) {
-      return a.runAtMillis - b.runAtMillis;
-    });
-    for (var i = 0; i < funcsToRun.length; ++i) {
-      try {
-        var funcToRun = funcsToRun[i];
-        this.nowMillis = funcToRun.runAtMillis;
-        funcToRun.funcToCall();
-        if (funcToRun.recurring) {
-          this.scheduleFunction(funcToRun.timeoutKey,
-              funcToRun.funcToCall,
-              funcToRun.millis,
-              true);
-        }
-      } catch(e) {
-      }
-    }
-    this.runFunctionsWithinRange(oldMillis, nowMillis);
-  }
-};
-
-jasmine.FakeTimer.prototype.scheduleFunction = function(timeoutKey, funcToCall, millis, recurring) {
-  this.scheduledFunctions[timeoutKey] = {
-    runAtMillis: this.nowMillis + millis,
-    funcToCall: funcToCall,
-    recurring: recurring,
-    timeoutKey: timeoutKey,
-    millis: millis
-  };
-};
-
-/**
- * @namespace
- */
-jasmine.Clock = {
-  defaultFakeTimer: new jasmine.FakeTimer(),
-
-  reset: function() {
-    jasmine.Clock.assertInstalled();
-    jasmine.Clock.defaultFakeTimer.reset();
-  },
-
-  tick: function(millis) {
-    jasmine.Clock.assertInstalled();
-    jasmine.Clock.defaultFakeTimer.tick(millis);
-  },
-
-  runFunctionsWithinRange: function(oldMillis, nowMillis) {
-    jasmine.Clock.defaultFakeTimer.runFunctionsWithinRange(oldMillis, nowMillis);
-  },
-
-  scheduleFunction: function(timeoutKey, funcToCall, millis, recurring) {
-    jasmine.Clock.defaultFakeTimer.scheduleFunction(timeoutKey, funcToCall, millis, recurring);
-  },
-
-  useMock: function() {
-    if (!jasmine.Clock.isInstalled()) {
-      var spec = jasmine.getEnv().currentSpec;
-      spec.after(jasmine.Clock.uninstallMock);
-
-      jasmine.Clock.installMock();
-    }
-  },
-
-  installMock: function() {
-    jasmine.Clock.installed = jasmine.Clock.defaultFakeTimer;
-  },
-
-  uninstallMock: function() {
-    jasmine.Clock.assertInstalled();
-    jasmine.Clock.installed = jasmine.Clock.real;
-  },
-
-  real: {
-    setTimeout: jasmine.getGlobal().setTimeout,
-    clearTimeout: jasmine.getGlobal().clearTimeout,
-    setInterval: jasmine.getGlobal().setInterval,
-    clearInterval: jasmine.getGlobal().clearInterval
-  },
-
-  assertInstalled: function() {
-    if (!jasmine.Clock.isInstalled()) {
-      throw new Error("Mock clock is not installed, use jasmine.Clock.useMock()");
-    }
-  },
-
-  isInstalled: function() {
-    return jasmine.Clock.installed == jasmine.Clock.defaultFakeTimer;
-  },
-
-  installed: null
-};
-jasmine.Clock.installed = jasmine.Clock.real;
-
-//else for IE support
-jasmine.getGlobal().setTimeout = function(funcToCall, millis) {
-  if (jasmine.Clock.installed.setTimeout.apply) {
-    return jasmine.Clock.installed.setTimeout.apply(this, arguments);
-  } else {
-    return jasmine.Clock.installed.setTimeout(funcToCall, millis);
-  }
-};
-
-jasmine.getGlobal().setInterval = function(funcToCall, millis) {
-  if (jasmine.Clock.installed.setInterval.apply) {
-    return jasmine.Clock.installed.setInterval.apply(this, arguments);
-  } else {
-    return jasmine.Clock.installed.setInterval(funcToCall, millis);
-  }
-};
-
-jasmine.getGlobal().clearTimeout = function(timeoutKey) {
-  if (jasmine.Clock.installed.clearTimeout.apply) {
-    return jasmine.Clock.installed.clearTimeout.apply(this, arguments);
-  } else {
-    return jasmine.Clock.installed.clearTimeout(timeoutKey);
-  }
-};
-
-jasmine.getGlobal().clearInterval = function(timeoutKey) {
-  if (jasmine.Clock.installed.clearTimeout.apply) {
-    return jasmine.Clock.installed.clearInterval.apply(this, arguments);
-  } else {
-    return jasmine.Clock.installed.clearInterval(timeoutKey);
-  }
-};
-
-/**
- * @constructor
- */
-jasmine.MultiReporter = function() {
-  this.subReporters_ = [];
-};
-jasmine.util.inherit(jasmine.MultiReporter, jasmine.Reporter);
-
-jasmine.MultiReporter.prototype.addReporter = function(reporter) {
-  this.subReporters_.push(reporter);
-};
-
-(function() {
-  var functionNames = [
-    "reportRunnerStarting",
-    "reportRunnerResults",
-    "reportSuiteResults",
-    "reportSpecStarting",
-    "reportSpecResults",
-    "log"
-  ];
-  for (var i = 0; i < functionNames.length; i++) {
-    var functionName = functionNames[i];
-    jasmine.MultiReporter.prototype[functionName] = (function(functionName) {
-      return function() {
-        for (var j = 0; j < this.subReporters_.length; j++) {
-          var subReporter = this.subReporters_[j];
-          if (subReporter[functionName]) {
-            subReporter[functionName].apply(subReporter, arguments);
-          }
-        }
-      };
-    })(functionName);
-  }
-})();
-/**
- * Holds results for a set of Jasmine spec. Allows for the results array to hold another jasmine.NestedResults
- *
- * @constructor
- */
-jasmine.NestedResults = function() {
-  /**
-   * The total count of results
-   */
-  this.totalCount = 0;
-  /**
-   * Number of passed results
-   */
-  this.passedCount = 0;
-  /**
-   * Number of failed results
-   */
-  this.failedCount = 0;
-  /**
-   * Was this suite/spec skipped?
-   */
-  this.skipped = false;
-  /**
-   * @ignore
-   */
-  this.items_ = [];
-};
-
-/**
- * Roll up the result counts.
- *
- * @param result
- */
-jasmine.NestedResults.prototype.rollupCounts = function(result) {
-  this.totalCount += result.totalCount;
-  this.passedCount += result.passedCount;
-  this.failedCount += result.failedCount;
-};
-
-/**
- * Adds a log message.
- * @param values Array of message parts which will be concatenated later.
- */
-jasmine.NestedResults.prototype.log = function(values) {
-  this.items_.push(new jasmine.MessageResult(values));
-};
-
-/**
- * Getter for the results: message & results.
- */
-jasmine.NestedResults.prototype.getItems = function() {
-  return this.items_;
-};
-
-/**
- * Adds a result, tracking counts (total, passed, & failed)
- * @param {jasmine.ExpectationResult|jasmine.NestedResults} result
- */
-jasmine.NestedResults.prototype.addResult = function(result) {
-  if (result.type != 'log') {
-    if (result.items_) {
-      this.rollupCounts(result);
-    } else {
-      this.totalCount++;
-      if (result.passed()) {
-        this.passedCount++;
-      } else {
-        this.failedCount++;
-      }
-    }
-  }
-  this.items_.push(result);
-};
-
-/**
- * @returns {Boolean} True if <b>everything</b> below passed
- */
-jasmine.NestedResults.prototype.passed = function() {
-  return this.passedCount === this.totalCount;
-};
-/**
- * Base class for pretty printing for expectation results.
- */
-jasmine.PrettyPrinter = function() {
-  this.ppNestLevel_ = 0;
-};
-
-/**
- * Formats a value in a nice, human-readable string.
- *
- * @param value
- */
-jasmine.PrettyPrinter.prototype.format = function(value) {
-  this.ppNestLevel_++;
-  try {
-    if (value === jasmine.undefined) {
-      this.emitScalar('undefined');
-    } else if (value === null) {
-      this.emitScalar('null');
-    } else if (value === jasmine.getGlobal()) {
-      this.emitScalar('<global>');
-    } else if (value.jasmineToString) {
-      this.emitScalar(value.jasmineToString());
-    } else if (typeof value === 'string') {
-      this.emitString(value);
-    } else if (jasmine.isSpy(value)) {
-      this.emitScalar("spy on " + value.identity);
-    } else if (value instanceof RegExp) {
-      this.emitScalar(value.toString());
-    } else if (typeof value === 'function') {
-      this.emitScalar('Function');
-    } else if (typeof value.nodeType === 'number') {
-      this.emitScalar('HTMLNode');
-    } else if (value instanceof Date) {
-      this.emitScalar('Date(' + value + ')');
-    } else if (value.__Jasmine_been_here_before__) {
-      this.emitScalar('<circular reference: ' + (jasmine.isArray_(value) ? 'Array' : 'Object') + '>');
-    } else if (jasmine.isArray_(value) || typeof value == 'object') {
-      value.__Jasmine_been_here_before__ = true;
-      if (jasmine.isArray_(value)) {
-        this.emitArray(value);
-      } else {
-        this.emitObject(value);
-      }
-      delete value.__Jasmine_been_here_before__;
-    } else {
-      this.emitScalar(value.toString());
-    }
-  } finally {
-    this.ppNestLevel_--;
-  }
-};
-
-jasmine.PrettyPrinter.prototype.iterateObject = function(obj, fn) {
-  for (var property in obj) {
-    if (!obj.hasOwnProperty(property)) continue;
-    if (property == '__Jasmine_been_here_before__') continue;
-    fn(property, obj.__lookupGetter__ ? (obj.__lookupGetter__(property) !== jasmine.undefined && 
-                                         obj.__lookupGetter__(property) !== null) : false);
-  }
-};
-
-jasmine.PrettyPrinter.prototype.emitArray = jasmine.unimplementedMethod_;
-jasmine.PrettyPrinter.prototype.emitObject = jasmine.unimplementedMethod_;
-jasmine.PrettyPrinter.prototype.emitScalar = jasmine.unimplementedMethod_;
-jasmine.PrettyPrinter.prototype.emitString = jasmine.unimplementedMethod_;
-
-jasmine.StringPrettyPrinter = function() {
-  jasmine.PrettyPrinter.call(this);
-
-  this.string = '';
-};
-jasmine.util.inherit(jasmine.StringPrettyPrinter, jasmine.PrettyPrinter);
-
-jasmine.StringPrettyPrinter.prototype.emitScalar = function(value) {
-  this.append(value);
-};
-
-jasmine.StringPrettyPrinter.prototype.emitString = function(value) {
-  this.append("'" + value + "'");
-};
-
-jasmine.StringPrettyPrinter.prototype.emitArray = function(array) {
-  if (this.ppNestLevel_ > jasmine.MAX_PRETTY_PRINT_DEPTH) {
-    this.append("Array");
-    return;
-  }
-
-  this.append('[ ');
-  for (var i = 0; i < array.length; i++) {
-    if (i > 0) {
-      this.append(', ');
-    }
-    this.format(array[i]);
-  }
-  this.append(' ]');
-};
-
-jasmine.StringPrettyPrinter.prototype.emitObject = function(obj) {
-  if (this.ppNestLevel_ > jasmine.MAX_PRETTY_PRINT_DEPTH) {
-    this.append("Object");
-    return;
-  }
-
-  var self = this;
-  this.append('{ ');
-  var first = true;
-
-  this.iterateObject(obj, function(property, isGetter) {
-    if (first) {
-      first = false;
-    } else {
-      self.append(', ');
-    }
-
-    self.append(property);
-    self.append(' : ');
-    if (isGetter) {
-      self.append('<getter>');
-    } else {
-      self.format(obj[property]);
-    }
-  });
-
-  this.append(' }');
-};
-
-jasmine.StringPrettyPrinter.prototype.append = function(value) {
-  this.string += value;
-};
-jasmine.Queue = function(env) {
-  this.env = env;
-
-  // parallel to blocks. each true value in this array means the block will
-  // get executed even if we abort
-  this.ensured = [];
-  this.blocks = [];
-  this.running = false;
-  this.index = 0;
-  this.offset = 0;
-  this.abort = false;
-};
-
-jasmine.Queue.prototype.addBefore = function(block, ensure) {
-  if (ensure === jasmine.undefined) {
-    ensure = false;
-  }
-
-  this.blocks.unshift(block);
-  this.ensured.unshift(ensure);
-};
-
-jasmine.Queue.prototype.add = function(block, ensure) {
-  if (ensure === jasmine.undefined) {
-    ensure = false;
-  }
-
-  this.blocks.push(block);
-  this.ensured.push(ensure);
-};
-
-jasmine.Queue.prototype.insertNext = function(block, ensure) {
-  if (ensure === jasmine.undefined) {
-    ensure = false;
-  }
-
-  this.ensured.splice((this.index + this.offset + 1), 0, ensure);
-  this.blocks.splice((this.index + this.offset + 1), 0, block);
-  this.offset++;
-};
-
-jasmine.Queue.prototype.start = function(onComplete) {
-  this.running = true;
-  this.onComplete = onComplete;
-  this.next_();
-};
-
-jasmine.Queue.prototype.isRunning = function() {
-  return this.running;
-};
-
-jasmine.Queue.LOOP_DONT_RECURSE = true;
-
-jasmine.Queue.prototype.next_ = function() {
-  var self = this;
-  var goAgain = true;
-
-  while (goAgain) {
-    goAgain = false;
-    
-    if (self.index < self.blocks.length && !(this.abort && !this.ensured[self.index])) {
-      var calledSynchronously = true;
-      var completedSynchronously = false;
-
-      var onComplete = function () {
-        if (jasmine.Queue.LOOP_DONT_RECURSE && calledSynchronously) {
-          completedSynchronously = true;
-          return;
-        }
-
-        if (self.blocks[self.index].abort) {
-          self.abort = true;
-        }
-
-        self.offset = 0;
-        self.index++;
-
-        var now = new Date().getTime();
-        if (self.env.updateInterval && now - self.env.lastUpdate > self.env.updateInterval) {
-          self.env.lastUpdate = now;
-          self.env.setTimeout(function() {
-            self.next_();
-          }, 0);
-        } else {
-          if (jasmine.Queue.LOOP_DONT_RECURSE && completedSynchronously) {
-            goAgain = true;
-          } else {
-            self.next_();
-          }
-        }
-      };
-      self.blocks[self.index].execute(onComplete);
-
-      calledSynchronously = false;
-      if (completedSynchronously) {
-        onComplete();
-      }
-      
-    } else {
-      self.running = false;
-      if (self.onComplete) {
-        self.onComplete();
-      }
-    }
-  }
-};
-
-jasmine.Queue.prototype.results = function() {
-  var results = new jasmine.NestedResults();
-  for (var i = 0; i < this.blocks.length; i++) {
-    if (this.blocks[i].results) {
-      results.addResult(this.blocks[i].results());
-    }
-  }
-  return results;
-};
-
-
-/**
- * Runner
- *
- * @constructor
- * @param {jasmine.Env} env
- */
-jasmine.Runner = function(env) {
-  var self = this;
-  self.env = env;
-  self.queue = new jasmine.Queue(env);
-  self.before_ = [];
-  self.after_ = [];
-  self.suites_ = [];
-};
-
-jasmine.Runner.prototype.execute = function() {
-  var self = this;
-  if (self.env.reporter.reportRunnerStarting) {
-    self.env.reporter.reportRunnerStarting(this);
-  }
-  self.queue.start(function () {
-    self.finishCallback();
-  });
-};
-
-jasmine.Runner.prototype.beforeEach = function(beforeEachFunction) {
-  beforeEachFunction.typeName = 'beforeEach';
-  this.before_.splice(0,0,beforeEachFunction);
-};
-
-jasmine.Runner.prototype.afterEach = function(afterEachFunction) {
-  afterEachFunction.typeName = 'afterEach';
-  this.after_.splice(0,0,afterEachFunction);
-};
-
-
-jasmine.Runner.prototype.finishCallback = function() {
-  this.env.reporter.reportRunnerResults(this);
-};
-
-jasmine.Runner.prototype.addSuite = function(suite) {
-  this.suites_.push(suite);
-};
-
-jasmine.Runner.prototype.add = function(block) {
-  if (block instanceof jasmine.Suite) {
-    this.addSuite(block);
-  }
-  this.queue.add(block);
-};
-
-jasmine.Runner.prototype.specs = function () {
-  var suites = this.suites();
-  var specs = [];
-  for (var i = 0; i < suites.length; i++) {
-    specs = specs.concat(suites[i].specs());
-  }
-  return specs;
-};
-
-jasmine.Runner.prototype.suites = function() {
-  return this.suites_;
-};
-
-jasmine.Runner.prototype.topLevelSuites = function() {
-  var topLevelSuites = [];
-  for (var i = 0; i < this.suites_.length; i++) {
-    if (!this.suites_[i].parentSuite) {
-      topLevelSuites.push(this.suites_[i]);
-    }
-  }
-  return topLevelSuites;
-};
-
-jasmine.Runner.prototype.results = function() {
-  return this.queue.results();
-};
-/**
- * Internal representation of a Jasmine specification, or test.
- *
- * @constructor
- * @param {jasmine.Env} env
- * @param {jasmine.Suite} suite
- * @param {String} description
- */
-jasmine.Spec = function(env, suite, description) {
-  if (!env) {
-    throw new Error('jasmine.Env() required');
-  }
-  if (!suite) {
-    throw new Error('jasmine.Suite() required');
-  }
-  var spec = this;
-  spec.id = env.nextSpecId ? env.nextSpecId() : null;
-  spec.env = env;
-  spec.suite = suite;
-  spec.description = description;
-  spec.queue = new jasmine.Queue(env);
-
-  spec.afterCallbacks = [];
-  spec.spies_ = [];
-
-  spec.results_ = new jasmine.NestedResults();
-  spec.results_.description = description;
-  spec.matchersClass = null;
-};
-
-jasmine.Spec.prototype.getFullName = function() {
-  return this.suite.getFullName() + ' ' + this.description + '.';
-};
-
-
-jasmine.Spec.prototype.results = function() {
-  return this.results_;
-};
-
-/**
- * All parameters are pretty-printed and concatenated together, then written to the spec's output.
- *
- * Be careful not to leave calls to <code>jasmine.log</code> in production code.
- */
-jasmine.Spec.prototype.log = function() {
-  return this.results_.log(arguments);
-};
-
-jasmine.Spec.prototype.runs = function (func) {
-  var block = new jasmine.Block(this.env, func, this);
-  this.addToQueue(block);
-  return this;
-};
-
-jasmine.Spec.prototype.addToQueue = function (block) {
-  if (this.queue.isRunning()) {
-    this.queue.insertNext(block);
-  } else {
-    this.queue.add(block);
-  }
-};
-
-/**
- * @param {jasmine.ExpectationResult} result
- */
-jasmine.Spec.prototype.addMatcherResult = function(result) {
-  this.results_.addResult(result);
-};
-
-jasmine.Spec.prototype.expect = function(actual) {
-  var positive = new (this.getMatchersClass_())(this.env, actual, this);
-  positive.not = new (this.getMatchersClass_())(this.env, actual, this, true);
-  return positive;
-};
-
-/**
- * Waits a fixed time period before moving to the next block.
- *
- * @deprecated Use waitsFor() instead
- * @param {Number} timeout milliseconds to wait
- */
-jasmine.Spec.prototype.waits = function(timeout) {
-  var waitsFunc = new jasmine.WaitsBlock(this.env, timeout, this);
-  this.addToQueue(waitsFunc);
-  return this;
-};
-
-/**
- * Waits for the latchFunction to return true before proceeding to the next block.
- *
- * @param {Function} latchFunction
- * @param {String} optional_timeoutMessage
- * @param {Number} optional_timeout
- */
-jasmine.Spec.prototype.waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
-  var latchFunction_ = null;
-  var optional_timeoutMessage_ = null;
-  var optional_timeout_ = null;
-
-  for (var i = 0; i < arguments.length; i++) {
-    var arg = arguments[i];
-    switch (typeof arg) {
-      case 'function':
-        latchFunction_ = arg;
-        break;
-      case 'string':
-        optional_timeoutMessage_ = arg;
-        break;
-      case 'number':
-        optional_timeout_ = arg;
-        break;
-    }
-  }
-
-  var waitsForFunc = new jasmine.WaitsForBlock(this.env, optional_timeout_, latchFunction_, optional_timeoutMessage_, this);
-  this.addToQueue(waitsForFunc);
-  return this;
-};
-
-jasmine.Spec.prototype.fail = function (e) {
-  var expectationResult = new jasmine.ExpectationResult({
-    passed: false,
-    message: e ? jasmine.util.formatException(e) : 'Exception',
-    trace: { stack: e.stack }
-  });
-  this.results_.addResult(expectationResult);
-};
-
-jasmine.Spec.prototype.getMatchersClass_ = function() {
-  return this.matchersClass || this.env.matchersClass;
-};
-
-jasmine.Spec.prototype.addMatchers = function(matchersPrototype) {
-  var parent = this.getMatchersClass_();
-  var newMatchersClass = function() {
-    parent.apply(this, arguments);
-  };
-  jasmine.util.inherit(newMatchersClass, parent);
-  jasmine.Matchers.wrapInto_(matchersPrototype, newMatchersClass);
-  this.matchersClass = newMatchersClass;
-};
-
-jasmine.Spec.prototype.finishCallback = function() {
-  this.env.reporter.reportSpecResults(this);
-};
-
-jasmine.Spec.prototype.finish = function(onComplete) {
-  this.removeAllSpies();
-  this.finishCallback();
-  if (onComplete) {
-    onComplete();
-  }
-};
-
-jasmine.Spec.prototype.after = function(doAfter) {
-  if (this.queue.isRunning()) {
-    this.queue.add(new jasmine.Block(this.env, doAfter, this), true);
-  } else {
-    this.afterCallbacks.unshift(doAfter);
-  }
-};
-
-jasmine.Spec.prototype.execute = function(onComplete) {
-  var spec = this;
-  if (!spec.env.specFilter(spec)) {
-    spec.results_.skipped = true;
-    spec.finish(onComplete);
-    return;
-  }
-
-  this.env.reporter.reportSpecStarting(this);
-
-  spec.env.currentSpec = spec;
-
-  spec.addBeforesAndAftersToQueue();
-
-  spec.queue.start(function () {
-    spec.finish(onComplete);
-  });
-};
-
-jasmine.Spec.prototype.addBeforesAndAftersToQueue = function() {
-  var runner = this.env.currentRunner();
-  var i;
-
-  for (var suite = this.suite; suite; suite = suite.parentSuite) {
-    for (i = 0; i < suite.before_.length; i++) {
-      this.queue.addBefore(new jasmine.Block(this.env, suite.before_[i], this));
-    }
-  }
-  for (i = 0; i < runner.before_.length; i++) {
-    this.queue.addBefore(new jasmine.Block(this.env, runner.before_[i], this));
-  }
-  for (i = 0; i < this.afterCallbacks.length; i++) {
-    this.queue.add(new jasmine.Block(this.env, this.afterCallbacks[i], this), true);
-  }
-  for (suite = this.suite; suite; suite = suite.parentSuite) {
-    for (i = 0; i < suite.after_.length; i++) {
-      this.queue.add(new jasmine.Block(this.env, suite.after_[i], this), true);
-    }
-  }
-  for (i = 0; i < runner.after_.length; i++) {
-    this.queue.add(new jasmine.Block(this.env, runner.after_[i], this), true);
-  }
-};
-
-jasmine.Spec.prototype.explodes = function() {
-  throw 'explodes function should not have been called';
-};
-
-jasmine.Spec.prototype.spyOn = function(obj, methodName, ignoreMethodDoesntExist) {
-  if (obj == jasmine.undefined) {
-    throw "spyOn could not find an object to spy upon for " + methodName + "()";
-  }
-
-  if (!ignoreMethodDoesntExist && obj[methodName] === jasmine.undefined) {
-    throw methodName + '() method does not exist';
-  }
-
-  if (!ignoreMethodDoesntExist && obj[methodName] && obj[methodName].isSpy) {
-    throw new Error(methodName + ' has already been spied upon');
-  }
-
-  var spyObj = jasmine.createSpy(methodName);
-
-  this.spies_.push(spyObj);
-  spyObj.baseObj = obj;
-  spyObj.methodName = methodName;
-  spyObj.originalValue = obj[methodName];
-
-  obj[methodName] = spyObj;
-
-  return spyObj;
-};
-
-jasmine.Spec.prototype.removeAllSpies = function() {
-  for (var i = 0; i < this.spies_.length; i++) {
-    var spy = this.spies_[i];
-    spy.baseObj[spy.methodName] = spy.originalValue;
-  }
-  this.spies_ = [];
-};
-
-/**
- * Internal representation of a Jasmine suite.
- *
- * @constructor
- * @param {jasmine.Env} env
- * @param {String} description
- * @param {Function} specDefinitions
- * @param {jasmine.Suite} parentSuite
- */
-jasmine.Suite = function(env, description, specDefinitions, parentSuite) {
-  var self = this;
-  self.id = env.nextSuiteId ? env.nextSuiteId() : null;
-  self.description = description;
-  self.queue = new jasmine.Queue(env);
-  self.parentSuite = parentSuite;
-  self.env = env;
-  self.before_ = [];
-  self.after_ = [];
-  self.children_ = [];
-  self.suites_ = [];
-  self.specs_ = [];
-};
-
-jasmine.Suite.prototype.getFullName = function() {
-  var fullName = this.description;
-  for (var parentSuite = this.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) {
-    fullName = parentSuite.description + ' ' + fullName;
-  }
-  return fullName;
-};
-
-jasmine.Suite.prototype.finish = function(onComplete) {
-  this.env.reporter.reportSuiteResults(this);
-  this.finished = true;
-  if (typeof(onComplete) == 'function') {
-    onComplete();
-  }
-};
-
-jasmine.Suite.prototype.beforeEach = function(beforeEachFunction) {
-  beforeEachFunction.typeName = 'beforeEach';
-  this.before_.unshift(beforeEachFunction);
-};
-
-jasmine.Suite.prototype.afterEach = function(afterEachFunction) {
-  afterEachFunction.typeName = 'afterEach';
-  this.after_.unshift(afterEachFunction);
-};
-
-jasmine.Suite.prototype.results = function() {
-  return this.queue.results();
-};
-
-jasmine.Suite.prototype.add = function(suiteOrSpec) {
-  this.children_.push(suiteOrSpec);
-  if (suiteOrSpec instanceof jasmine.Suite) {
-    this.suites_.push(suiteOrSpec);
-    this.env.currentRunner().addSuite(suiteOrSpec);
-  } else {
-    this.specs_.push(suiteOrSpec);
-  }
-  this.queue.add(suiteOrSpec);
-};
-
-jasmine.Suite.prototype.specs = function() {
-  return this.specs_;
-};
-
-jasmine.Suite.prototype.suites = function() {
-  return this.suites_;
-};
-
-jasmine.Suite.prototype.children = function() {
-  return this.children_;
-};
-
-jasmine.Suite.prototype.execute = function(onComplete) {
-  var self = this;
-  this.queue.start(function () {
-    self.finish(onComplete);
-  });
-};
-jasmine.WaitsBlock = function(env, timeout, spec) {
-  this.timeout = timeout;
-  jasmine.Block.call(this, env, null, spec);
-};
-
-jasmine.util.inherit(jasmine.WaitsBlock, jasmine.Block);
-
-jasmine.WaitsBlock.prototype.execute = function (onComplete) {
-  if (jasmine.VERBOSE) {
-    this.env.reporter.log('>> Jasmine waiting for ' + this.timeout + ' ms...');
-  }
-  this.env.setTimeout(function () {
-    onComplete();
-  }, this.timeout);
-};
-/**
- * A block which waits for some condition to become true, with timeout.
- *
- * @constructor
- * @extends jasmine.Block
- * @param {jasmine.Env} env The Jasmine environment.
- * @param {Number} timeout The maximum time in milliseconds to wait for the condition to become true.
- * @param {Function} latchFunction A function which returns true when the desired condition has been met.
- * @param {String} message The message to display if the desired condition hasn't been met within the given time period.
- * @param {jasmine.Spec} spec The Jasmine spec.
- */
-jasmine.WaitsForBlock = function(env, timeout, latchFunction, message, spec) {
-  this.timeout = timeout || env.defaultTimeoutInterval;
-  this.latchFunction = latchFunction;
-  this.message = message;
-  this.totalTimeSpentWaitingForLatch = 0;
-  jasmine.Block.call(this, env, null, spec);
-};
-jasmine.util.inherit(jasmine.WaitsForBlock, jasmine.Block);
-
-jasmine.WaitsForBlock.TIMEOUT_INCREMENT = 10;
-
-jasmine.WaitsForBlock.prototype.execute = function(onComplete) {
-  if (jasmine.VERBOSE) {
-    this.env.reporter.log('>> Jasmine waiting for ' + (this.message || 'something to happen'));
-  }
-  var latchFunctionResult;
-  try {
-    latchFunctionResult = this.latchFunction.apply(this.spec);
-  } catch (e) {
-    this.spec.fail(e);
-    onComplete();
-    return;
-  }
-
-  if (latchFunctionResult) {
-    onComplete();
-  } else if (this.totalTimeSpentWaitingForLatch >= this.timeout) {
-    var message = 'timed out after ' + this.timeout + ' msec waiting for ' + (this.message || 'something to happen');
-    this.spec.fail({
-      name: 'timeout',
-      message: message
-    });
-
-    this.abort = true;
-    onComplete();
-  } else {
-    this.totalTimeSpentWaitingForLatch += jasmine.WaitsForBlock.TIMEOUT_INCREMENT;
-    var self = this;
-    this.env.setTimeout(function() {
-      self.execute(onComplete);
-    }, jasmine.WaitsForBlock.TIMEOUT_INCREMENT);
-  }
-};
-
-jasmine.version_= {
-  "major": 1,
-  "minor": 3,
-  "build": 1,
-  "revision": 1354556913
-};
diff --git a/all/phantom.js b/all/phantom.js
deleted file mode 100644
index af54e6f75e..0000000000
--- a/all/phantom.js
+++ /dev/null
@@ -1,44 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * This module provides a bridge from content-land to phantom-land via the
- * window.callPhantom interface.
- */
-
-var console = require("./console");
-var global = Function("return this")();
-
-if (global.callPhantom) {
-    // Phantom's onConsoleMessage support is lacking (only one argument
-    // supported, and it must be a string), so we use callPhantom to
-    // forward console messages instead.
-    console.addListener(function(method, args) {
-        global.callPhantom({
-            type: "console",
-            method: method,
-            args: args
-        });
-    });
-
-    exports.exit = function(code) {
-        global.callPhantom({
-            type: "exit",
-            code: code
-        });
-    };
-
-} else {
-    exports.exit = function() {};
-}

From bd150ec658aff506b9bc4ef612a2c1b1bbf20f96 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Paul=20O=E2=80=99Shannessy?= <paul@oshannessy.com>
Date: Fri, 28 Jun 2013 16:31:40 -0700
Subject: [PATCH 85/94] Clean up unused variables for lint

---
 src/core/__tests__/ReactDOMTextarea-test.js | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/core/__tests__/ReactDOMTextarea-test.js b/src/core/__tests__/ReactDOMTextarea-test.js
index 0ed7417d6a..680ed9c3e1 100644
--- a/src/core/__tests__/ReactDOMTextarea-test.js
+++ b/src/core/__tests__/ReactDOMTextarea-test.js
@@ -22,7 +22,6 @@
 describe('ReactDOMTextarea', function() {
   var React;
   var ReactTestUtils;
-  var getTextContentAccessor;
 
   beforeEach(function() {
     React = require('React');
@@ -53,13 +52,13 @@ describe('ReactDOMTextarea', function() {
 
   it("should throw with multiple or invalid children", function() {
     expect(function() {
-      var stub = ReactTestUtils.renderIntoDocument(
+      ReactTestUtils.renderIntoDocument(
         <textarea>{'hello'}{'there'}</textarea>
       );
     }).toThrow();
 
     expect(function() {
-      var stub = ReactTestUtils.renderIntoDocument(
+      ReactTestUtils.renderIntoDocument(
         <textarea><strong /></textarea>
       );
     }).toThrow();

From 738de8cfa846936ae754ccfda607e4fb41c2170b Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 28 Jun 2013 16:33:45 -0700
Subject: [PATCH 86/94] Improve `findComponentRoot` Error Message

Instead of simply logging the React ID of the `ancestorNode` when `findComponentRoot` fails, use a `try ... finally` to `console.error` the `ancestorNode`. This allows modern web inspectors to actually log a reference to the node (which may not have a React ID).

This means when people run into the problem, they will not have to execute:

  require('ReactID').getNode(<copy+paste>);

NOTE: Admittedly, this will not log anything in IE8. That's fine, since IE8 has shitty console logging anyway.
---
 src/core/ReactInstanceHandles.js                | 11 +++++++----
 src/core/__tests__/ReactInstanceHandles-test.js |  7 +++----
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/core/ReactInstanceHandles.js b/src/core/ReactInstanceHandles.js
index 000856604b..02ea765e0a 100644
--- a/src/core/ReactInstanceHandles.js
+++ b/src/core/ReactInstanceHandles.js
@@ -296,12 +296,15 @@ var ReactInstanceHandles = {
       }
       child = child.nextSibling;
     }
+    global.console && console.error && console.error(
+      'Error while invoking `findComponentRoot` with the following ' +
+      'ancestor node:',
+      ancestorNode
+    );
     invariant(
       false,
-      'findComponentRoot: Unable to find element by React ID, `%s`. This ' +
-      'indicates that someone (or the browser) has mutated the DOM tree in ' +
-      'an unexpected way. Try inspecting the child nodes of the element with ' +
-      'React ID, `%s`.',
+      'findComponentRoot(..., %s): Unable to find element. This probably ' +
+      'means the DOM was unexpectedly mutated (e.g. by the browser).',
       id,
       ReactID.getID(ancestorNode)
     );
diff --git a/src/core/__tests__/ReactInstanceHandles-test.js b/src/core/__tests__/ReactInstanceHandles-test.js
index 4cde75ab5d..110612c1c8 100644
--- a/src/core/__tests__/ReactInstanceHandles-test.js
+++ b/src/core/__tests__/ReactInstanceHandles-test.js
@@ -139,10 +139,9 @@ describe('ReactInstanceHandles', function() {
           ReactID.getID(childNodeB)
         );
       }).toThrow(
-        'Invariant Violation: findComponentRoot: Unable to find element by ' +
-        'React ID, `.react[0].1:0`. This indicates that someone (or the ' +
-        'browser) has mutated the DOM tree in an unexpected way. Try ' +
-        'inspecting the child nodes of the element with React ID, `.react[0]`.'
+        'Invariant Violation: findComponentRoot(..., .react[0].1:0): Unable ' +
+        'to find element. This probably means the DOM was unexpectedly ' +
+        'mutated (e.g. by the browser).'
       );
     });
   });

From 55176116a225c7664d082580faa6dde12a3bb00e Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 28 Jun 2013 16:33:49 -0700
Subject: [PATCH 87/94] Implement `ReactDOMTextarea`

This changes `ReactDOMTextarea` to accept `defaultValue` and `value`. It will warn people about using children (but allow it and treat it as `defaultValue`, which is the current behavior).
---
 src/core/ReactDOM.js                          |   6 +-
 src/core/ReactDOMTextarea.js                  |  92 -------------
 src/core/__tests__/ReactDOMTextarea-test.js   |  66 ---------
 src/dom/components/ReactDOMTextarea.js        | 129 ++++++++++++++++++
 .../__tests__/ReactDOMTextarea-test.js        |  93 +++++++++++++
 5 files changed, 224 insertions(+), 162 deletions(-)
 delete mode 100644 src/core/ReactDOMTextarea.js
 delete mode 100644 src/core/__tests__/ReactDOMTextarea-test.js
 create mode 100644 src/dom/components/ReactDOMTextarea.js
 create mode 100644 src/dom/components/__tests__/ReactDOMTextarea-test.js

diff --git a/src/core/ReactDOM.js b/src/core/ReactDOM.js
index 0b7c4e3907..2a9749c9be 100644
--- a/src/core/ReactDOM.js
+++ b/src/core/ReactDOM.js
@@ -80,8 +80,7 @@ var ReactDOM = objMapKeyVal({
   embed: true,
   fieldset: false,
   footer: false,
-  // Danger: this gets monkeypatched! See ReactDOMForm for more info.
-  form: false,
+  form: false, // NOTE: Injected, see `ReactDOMForm`.
   h1: false,
   h2: false,
   h3: false,
@@ -116,8 +115,7 @@ var ReactDOM = objMapKeyVal({
   table: false,
   tbody: false,
   td: false,
-  // Danger: this gets monkeypatched! See ReactDOMTextarea for more info.
-  textarea: false,
+  textarea: false, // NOTE: Injected, see `ReactDOMTextarea`.
   tfoot: false,
   th: false,
   thead: false,
diff --git a/src/core/ReactDOMTextarea.js b/src/core/ReactDOMTextarea.js
deleted file mode 100644
index a9f22e0b65..0000000000
--- a/src/core/ReactDOMTextarea.js
+++ /dev/null
@@ -1,92 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @providesModule ReactDOMTextarea
- */
-
-"use strict";
-
-var ReactCompositeComponent = require('ReactCompositeComponent');
-var ReactDOM = require('ReactDOM');
-
-var invariant = require('invariant');
-
-// Store a reference to the <textarea> `ReactNativeComponent`.
-var textarea = ReactDOM.textarea;
-
-// For quickly matching children type, to test if can be treated as content.
-var CONTENT_TYPES = {'string': true, 'number': true};
-
-var getTextContent = function(props) {
-  if (!props) {
-    return '';
-  }
-
-  invariant(
-    props.dangerouslySetInnerHTML == null,
-    '`dangerouslySetInnerHTML` does not make sense on textarea.'
-  );
-
-  var content;
-  if (Array.isArray(props.children)) {
-    invariant(
-      props.children.length <= 1,
-      'textarea can have at most one child'
-    );
-    content = props.children[0];
-  } else if (props.children != null) {
-    content = props.children;
-  } else {
-    content = props.content;
-  }
-
-  invariant(
-    content == null || CONTENT_TYPES[typeof content],
-    'textarea must contain a single string or number, not an array or ' +
-    'object.'
-  );
-  return content != null ? '' + content : '';
-};
-
-/**
- * Since setting .textContent on a dirty <textarea> doesn't update its value,
- * we intercept prop changes here to make sure that value is updated.
- */
-var ReactDOMTextarea = ReactCompositeComponent.createClass({
-  getInitialState: function() {
-    // We keep the original value of content or children here so that
-    // ReactNativeComponent doesn't update textContent (unnecessary since we
-    // update value).
-    return {
-      initialContent: getTextContent(this.props)
-    };
-  },
-
-  render: function() {
-    return this.transferPropsTo(textarea({
-      content: this.state.initialContent
-    }));
-  },
-
-  componentDidUpdate: function(prevProps, prevState, rootNode) {
-    var oldContent = getTextContent(prevProps);
-    var newContent = getTextContent(this.props);
-    if (oldContent !== newContent && rootNode.value !== newContent) {
-      rootNode.value = newContent;
-    }
-  }
-});
-
-module.exports = ReactDOMTextarea;
diff --git a/src/core/__tests__/ReactDOMTextarea-test.js b/src/core/__tests__/ReactDOMTextarea-test.js
deleted file mode 100644
index 680ed9c3e1..0000000000
--- a/src/core/__tests__/ReactDOMTextarea-test.js
+++ /dev/null
@@ -1,66 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @jsx React.DOM
- * @emails react-core
- */
-
-"use strict";
-
-describe('ReactDOMTextarea', function() {
-  var React;
-  var ReactTestUtils;
-
-  beforeEach(function() {
-    React = require('React');
-    ReactTestUtils = require('ReactTestUtils');
-  });
-
-  it("should update value", function() {
-    var stub = ReactTestUtils.renderIntoDocument(<textarea>giraffe</textarea>);
-    var node = stub.getDOMNode();
-
-    expect(node.value).toEqual('giraffe');
-
-    stub.replaceProps({ children: 'gorilla' });
-    expect(node.value).toEqual('gorilla');
-
-    stub.replaceProps({ children: 17 });
-    expect(node.value).toEqual('17');
-
-    stub.replaceProps({ children: [42] });
-    expect(node.value).toEqual('42');
-
-    stub.replaceProps({ children: null });
-    expect(node.value).toEqual('');
-
-    stub.replaceProps({ content: 'eggplant' });
-    expect(node.value).toEqual('eggplant');
-  });
-
-  it("should throw with multiple or invalid children", function() {
-    expect(function() {
-      ReactTestUtils.renderIntoDocument(
-        <textarea>{'hello'}{'there'}</textarea>
-      );
-    }).toThrow();
-
-    expect(function() {
-      ReactTestUtils.renderIntoDocument(
-        <textarea><strong /></textarea>
-      );
-    }).toThrow();
-  });
-});
diff --git a/src/dom/components/ReactDOMTextarea.js b/src/dom/components/ReactDOMTextarea.js
new file mode 100644
index 0000000000..ddba826a23
--- /dev/null
+++ b/src/dom/components/ReactDOMTextarea.js
@@ -0,0 +1,129 @@
+/**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @providesModule ReactDOMTextarea
+ */
+
+"use strict";
+
+var DOMPropertyOperations = require('DOMPropertyOperations');
+var ReactCompositeComponent = require('ReactCompositeComponent');
+var ReactDOM = require('ReactDOM');
+
+var invariant = require('invariant');
+var merge = require('merge');
+
+// Store a reference to the <textarea> `ReactNativeComponent`.
+var textarea = ReactDOM.textarea;
+
+// For quickly matching children type, to test if can be treated as content.
+var CONTENT_TYPES = {'string': true, 'number': true};
+
+/**
+ * Implements a <textarea> native component that allows setting `value`, and
+ * `defaultValue`. This differs from the traditional DOM API because value is
+ * usually set as PCDATA children.
+ *
+ * If `value` is not supplied (or null/undefined), user actions that affect the
+ * value will trigger updates to the element.
+ *
+ * If `value` is supplied (and not null/undefined), the rendered element will
+ * not trigger updates to the element. Instead, the `value` prop must change in
+ * order for the rendered element to be updated.
+ *
+ * The rendered element will be initialized with an empty value, the prop
+ * `defaultValue` if specified, or the children content (deprecated).
+ */
+var ReactDOMTextarea = ReactCompositeComponent.createClass({
+
+  getInitialState: function() {
+    var defaultValue = this.props.defaultValue;
+    // TODO (yungsters): Remove support for children content in <textarea>.
+    var children = this.props.children;
+    if (children != null) {
+      global.console && console.warn && console.warn(
+        'Use the `defaultValue` or `value` props instead of setting children ' +
+        'on <textarea>.'
+      );
+      invariant(
+        defaultValue == null,
+        'If you supply `defaultValue` on a <textarea>, do not pass children.'
+      );
+      if (Array.isArray(children)) {
+        invariant(
+          children.length <= 1,
+          '<textarea> can only have at most one child.'
+        );
+        children = children[0];
+      }
+      invariant(
+        CONTENT_TYPES[typeof children],
+        'If you specify children to <textarea>, it must be a single string ' +
+        'or number., not an array or object.'
+      );
+      defaultValue = '' + children;
+    }
+    defaultValue = defaultValue || '';
+    return {
+      // We save the initial value so that `ReactNativeComponent` doesn't update
+      // `textContent` (unnecessary since we update value).
+      initialValue: this.props.value != null ? this.props.value : defaultValue,
+      value: defaultValue
+    };
+  },
+
+  getValue: function() {
+    return this.props.value != null ? this.props.value : this.state.value;
+  },
+
+  render: function() {
+    // Clone `this.props` so we don't mutate the input.
+    var props = merge(this.props);
+
+    invariant(
+      props.dangerouslySetInnerHTML == null,
+      '`dangerouslySetInnerHTML` does not make sense on <textarea>.'
+    );
+
+    props.value = this.getValue();
+    props.onChange = this.handleChange;
+
+    // Always set children to the same thing. In IE9, the selection range will
+    // get reset if `textContent` is mutated.
+    return textarea(props, this.state.initialValue);
+  },
+
+  componentDidUpdate: function(prevProps, prevState, rootNode) {
+    if (this.props.value != null) {
+      DOMPropertyOperations.setValueForProperty(
+        rootNode,
+        'value',
+        this.props.value || ''
+      );
+    }
+  },
+
+  handleChange: ReactCompositeComponent.autoBind(function(event) {
+    var returnValue;
+    if (this.props.onChange) {
+      returnValue = this.props.onChange(event);
+    }
+    this.setState({value: event.target.value});
+    return returnValue;
+  })
+
+});
+
+module.exports = ReactDOMTextarea;
diff --git a/src/dom/components/__tests__/ReactDOMTextarea-test.js b/src/dom/components/__tests__/ReactDOMTextarea-test.js
new file mode 100644
index 0000000000..5fbb36a7c6
--- /dev/null
+++ b/src/dom/components/__tests__/ReactDOMTextarea-test.js
@@ -0,0 +1,93 @@
+/**
+ * Copyright 2013 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @jsx React.DOM
+ * @emails react-core
+ */
+
+"use strict";
+
+/*jshint evil:true */
+
+describe('ReactDOMTextarea', function() {
+  var React;
+  var ReactTestUtils;
+
+  var renderTextarea;
+
+  beforeEach(function() {
+    React = require('React');
+    ReactTestUtils = require('ReactTestUtils');
+
+    renderTextarea = function(component) {
+      var stub = ReactTestUtils.renderIntoDocument(component);
+      var node = stub.getDOMNode();
+      // Polyfilling the browser's quirky behavior.
+      node.value = node.innerHTML;
+      return node;
+    };
+  });
+
+  it('should allow setting `defaultValue`', function() {
+    var stub = <textarea defaultValue="giraffe" />;
+    var node = renderTextarea(stub);
+
+    expect(node.value).toBe('giraffe');
+
+    // Changing `defaultValue` should do nothing.
+    stub.replaceProps({defaultValue: 'gorilla'});
+    expect(node.value).toEqual('giraffe');
+  });
+
+  it('should allow setting `value`', function() {
+    var stub = <textarea value="giraffe" />;
+    var node = renderTextarea(stub);
+
+    expect(node.value).toBe('giraffe');
+
+    stub.replaceProps({value: 'gorilla'});
+    expect(node.value).toEqual('gorilla');
+  });
+
+  it('should treat children like `defaultValue`', function() {
+    var stub = <textarea>giraffe</textarea>;
+    var node = renderTextarea(stub);
+
+    expect(node.value).toBe('giraffe');
+
+    // Changing children should do nothing, it functions like `defaultValue`.
+    stub.replaceProps({children: 'gorilla'});
+    expect(node.value).toEqual('giraffe');
+  });
+
+  it('should allow numbers as children', function() {
+    var node = renderTextarea(<textarea>{17}</textarea>);
+    expect(node.value).toBe('17');
+  });
+
+  it("should throw with multiple or invalid children", function() {
+    expect(function() {
+      ReactTestUtils.renderIntoDocument(
+        <textarea>{'hello'}{'there'}</textarea>
+      );
+    }).toThrow();
+
+    expect(function() {
+      ReactTestUtils.renderIntoDocument(
+        <textarea><strong /></textarea>
+      );
+    }).toThrow();
+  });
+});

From 15272f30f426dc02349856f4a4dc0f0dad8afb9a Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 28 Jun 2013 16:33:56 -0700
Subject: [PATCH 88/94] Don't keep the HTML escaped ID internally, only in HTML
 generation

A dynamic value can be provided as a key to a child. Either as part of an object
or key property. This becomes part of the component's ID.

We have to be careful to escape this key before inserting it into the DOM since
it could become a vulnerability. We fixed this by escaping just the keys.

However, the current implementation breaks when you used escaped keys. The
internal value is escaped and the value used by getAttributeNode and
getElementById are both unescaped.

This fixes that by keeping the unescaped value internally but escaping it right
before the HTML is generated (like any other attribute).

This is important since business logic IDs (that should be used as keys)
contains characters that need to be escaped.
---
 src/core/ReactNativeComponent.js         |  3 +-
 src/core/__tests__/ReactIdentity-test.js | 46 ++++++++++++++++++++++++
 src/utils/__tests__/mapChildren-test.js  |  4 +--
 src/utils/flattenChildren.js             | 10 ++----
 4 files changed, 53 insertions(+), 10 deletions(-)

diff --git a/src/core/ReactNativeComponent.js b/src/core/ReactNativeComponent.js
index c6a9783e90..17f205f278 100644
--- a/src/core/ReactNativeComponent.js
+++ b/src/core/ReactNativeComponent.js
@@ -139,7 +139,8 @@ ReactNativeComponent.Mixin = {
       }
     }
 
-    return ret + ' ' + ReactID.ATTR_NAME + '="' + this._rootNodeID + '">';
+    var escapedID = escapeTextForBrowser(this._rootNodeID);
+    return ret + ' ' + ReactID.ATTR_NAME + '="' + escapedID + '">';
   },
 
   /**
diff --git a/src/core/__tests__/ReactIdentity-test.js b/src/core/__tests__/ReactIdentity-test.js
index 36998e9f62..9d638d5579 100644
--- a/src/core/__tests__/ReactIdentity-test.js
+++ b/src/core/__tests__/ReactIdentity-test.js
@@ -106,6 +106,52 @@ describe('ReactIdentity', function() {
     checkId(node.childNodes[2].firstChild, '.r[0].[0:2].[0:chipmunk]');
   });
 
+  function renderAComponentWithKeyIntoContainer(key, container) {
+    var span1 = <span key={key} />;
+    var span2 = <span />;
+
+    var map = {};
+    map[key] = span2;
+
+    React.renderComponent(<div>{[span1, map]}</div>, container);
+
+    expect(span1.getDOMNode()).not.toBe(null);
+    expect(span2.getDOMNode()).not.toBe(null);
+
+    checkId(span1.getDOMNode(), '.r[0].[0:0:' + key + ']');
+    checkId(span2.getDOMNode(), '.r[0].[1]{' + key + '}');
+  }
+
+  it('should allow any character as a key, in a detached parent', function() {
+    var detachedContainer = document.createElement('div');
+    renderAComponentWithKeyIntoContainer("<'WEIRD/&\\key'>", detachedContainer);
+  });
+
+  it('should allow any character as a key, in an attached parent', function() {
+    // This test exists to protect against implementation details that
+    // incorrectly query escaped IDs using DOM tools like getElementById.
+    var attachedContainer = document.createElement('div');
+    document.body.appendChild(attachedContainer);
+
+    renderAComponentWithKeyIntoContainer("<'WEIRD/&\\key'>", attachedContainer);
+
+    document.body.removeChild(attachedContainer);
+  });
+
+  it('should not allow scripts in keys to execute', function() {
+    var h4x0rKey = '"><script>window.YOUVEBEENH4X0RED=true;</script><div id="';
+
+    var attachedContainer = document.createElement('div');
+    document.body.appendChild(attachedContainer);
+
+    renderAComponentWithKeyIntoContainer(h4x0rKey, attachedContainer);
+
+    document.body.removeChild(attachedContainer);
+
+    // If we get this far, make sure we haven't executed the code
+    expect(window.YOUVEBEENH4X0RED).toBe(undefined);
+  });
+
   it('should let restructured components retain their uniqueness', function() {
     var instance0 = <span />;
     var instance1 = <span />;
diff --git a/src/utils/__tests__/mapChildren-test.js b/src/utils/__tests__/mapChildren-test.js
index 8376d28f5a..3e1d3ca236 100644
--- a/src/utils/__tests__/mapChildren-test.js
+++ b/src/utils/__tests__/mapChildren-test.js
@@ -94,7 +94,7 @@ describe('mapChildren', function() {
 
     expect(rendered.props.children[0]).not.toBe(simpleKid);
     expect(rendered.props.children[0].props.children[0]).toBe(simpleKid);
-    expect(rendered.props.children).toHaveKeys(['0:0:0:simple']);
+    expect(rendered.props.children).toHaveKeys(['1:0:0:simple']);
     expect(rendered.props.children[0].props.children)
       .toHaveKeys(['0:simple']);
   });
@@ -128,7 +128,7 @@ describe('mapChildren', function() {
     expect(mapFn).toHaveBeenCalledWith(kidThree, '0:three', 2);
     expect(rendered.props.children).not.toEqual(instance.props.children);
     expect(rendered.props.children).toHaveKeys([
-      '0:0:0:one', '0:0:0:two', '0:0:0:three'
+      '1:0:0:one', '1:0:0:two', '1:0:0:three'
     ]);
   });
 });
diff --git a/src/utils/flattenChildren.js b/src/utils/flattenChildren.js
index 2728220b19..7f18ab2fbd 100644
--- a/src/utils/flattenChildren.js
+++ b/src/utils/flattenChildren.js
@@ -20,8 +20,6 @@
 
 var ReactTextComponent = require('ReactTextComponent');
 
-var escapeTextForBrowser = require('escapeTextForBrowser');
-
 var throwIf = require('throwIf');
 
 /**
@@ -47,16 +45,15 @@ var DUPLICATE_KEY_ERROR =
 var ONLY_CHILD_NAME = '0';
 
 var flattenChildrenImpl = function(res, children, nameSoFar) {
-  var key, escapedKey;
+  var key;
   if (Array.isArray(children)) {
     for (var i = 0; i < children.length; i++) {
       var child = children[i];
       key = child && (child._key || (child.props && child.props.key));
-      escapedKey = key ? escapeTextForBrowser(key) : ('' + i);
       flattenChildrenImpl(
         res,
         child,
-        nameSoFar + '[' + escapedKey + ']'
+        nameSoFar + '[' + (key ? key : ('' + i)) + ']'
       );
     }
   } else {
@@ -76,11 +73,10 @@ var flattenChildrenImpl = function(res, children, nameSoFar) {
         throwIf(children && children.nodeType === 1, INVALID_CHILD);
         for (key in children) {
           if (children.hasOwnProperty(key)) {
-            escapedKey = escapeTextForBrowser(key);
             flattenChildrenImpl(
               res,
               children[key],
-              nameSoFar + '{' + escapedKey + '}'
+              nameSoFar + '{' + key + '}'
             );
           }
         }

From ca19ffb0837bd9211375b77e589fcc40f658c34e Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Fri, 28 Jun 2013 16:34:00 -0700
Subject: [PATCH 89/94] use .apply instead of .call in ReactCompositeComponent

This was a bit ridiculous.. let's just use arguments as it's supposed to
be used.
---
 src/core/ReactCompositeComponent.js | 21 ++++++---------------
 1 file changed, 6 insertions(+), 15 deletions(-)

diff --git a/src/core/ReactCompositeComponent.js b/src/core/ReactCompositeComponent.js
index a7ef000e18..be911dc6f8 100644
--- a/src/core/ReactCompositeComponent.js
+++ b/src/core/ReactCompositeComponent.js
@@ -398,13 +398,9 @@ function mixSpecIntoComponent(Constructor, spec) {
  * @private
  */
 function createChainedFunction(one, two) {
-  return function chainedFunction(a, b, c, d, e, f, g, tooMany) {
-    invariant(
-      typeof tooMany === 'undefined',
-      'Chained function can only take a maximum of 7 arguments.'
-    );
-    one.call(this, a, b, c, d, e, f, g);
-    two.call(this, a, b, c, d, e, f, g);
+  return function chainedFunction() {
+    one.apply(this, arguments);
+    two.apply(this, arguments);
   };
 }
 
@@ -833,14 +829,9 @@ var ReactCompositeComponentMixin = {
    */
   _bindAutoBindMethod: function(method) {
     var component = this;
-    function autoBound(a, b, c, d, e, f, g, tooMany) {
-      invariant(
-        typeof tooMany === 'undefined',
-        'React.autoBind(...): Methods can only take a maximum of 7 arguments.'
-      );
-      return method.call(component, a, b, c, d, e, f, g);
-    }
-    return autoBound;
+    return function() {
+      return method.apply(component, arguments);
+    };
   }
 
 };

From 2aa5631e2eba008327b71f529fb9a975fecbcf99 Mon Sep 17 00:00:00 2001
From: Ben Alpert <spicyjalapeno@gmail.com>
Date: Mon, 1 Jul 2013 11:54:13 -0700
Subject: [PATCH 90/94] Use proper names for scroll metric properties

---
 src/event/synthetic/SyntheticMouseEvent.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/event/synthetic/SyntheticMouseEvent.js b/src/event/synthetic/SyntheticMouseEvent.js
index 8dde7e1045..1e894ae938 100644
--- a/src/event/synthetic/SyntheticMouseEvent.js
+++ b/src/event/synthetic/SyntheticMouseEvent.js
@@ -61,12 +61,12 @@ var MouseEventInterface = {
   pageX: function(event) {
     return 'pageX' in event ?
       event.pageX :
-      event.clientX + ViewportMetrics.currentPageScrollLeft;
+      event.clientX + ViewportMetrics.currentScrollLeft;
   },
   pageY: function(event) {
     return 'pageY' in event ?
       event.pageY :
-      event.clientY + ViewportMetrics.currentPageScrollTop;
+      event.clientY + ViewportMetrics.currentScrollTop;
   }
 };
 

From 40bebf0c861700b387dc848a2538eef4b96778a4 Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 1 Jul 2013 12:59:18 -0700
Subject: [PATCH 91/94] Fix `ReactDOMInput` and `ReactDOMTextarea` Race
 Condition

This fixes a race condition if the `onClick` tries to update the input or textarea (e.g. by calling `setState`):

  <input
    onClick={function(event) {
      this.setState({somethingElse: true}); // Triggers an update.
      // event.target.value is now equal to the old value, fail...
      this.props.onChange(event);
    })
  />
---
 src/dom/components/ReactDOMInput.js    | 7 +++++++
 src/dom/components/ReactDOMTextarea.js | 7 +++++++
 2 files changed, 14 insertions(+)

diff --git a/src/dom/components/ReactDOMInput.js b/src/dom/components/ReactDOMInput.js
index ad3c500ef1..2d552fc923 100644
--- a/src/dom/components/ReactDOMInput.js
+++ b/src/dom/components/ReactDOMInput.js
@@ -52,6 +52,11 @@ var ReactDOMInput = ReactCompositeComponent.createClass({
     };
   },
 
+  shouldComponentUpdate: function() {
+    // Defer any updates to this component during the `onChange` handler.
+    return !this._isChanging;
+  },
+
   getChecked: function() {
     return this.props.checked != null ? this.props.checked : this.state.checked;
   },
@@ -91,7 +96,9 @@ var ReactDOMInput = ReactCompositeComponent.createClass({
   handleChange: ReactCompositeComponent.autoBind(function(event) {
     var returnValue;
     if (this.props.onChange) {
+      this._isChanging = true;
       returnValue = this.props.onChange(event);
+      this._isChanging = false;
     }
     this.setState({
       checked: event.target.checked,
diff --git a/src/dom/components/ReactDOMTextarea.js b/src/dom/components/ReactDOMTextarea.js
index ddba826a23..84e2132a90 100644
--- a/src/dom/components/ReactDOMTextarea.js
+++ b/src/dom/components/ReactDOMTextarea.js
@@ -84,6 +84,11 @@ var ReactDOMTextarea = ReactCompositeComponent.createClass({
     };
   },
 
+  shouldComponentUpdate: function() {
+    // Defer any updates to this component during the `onChange` handler.
+    return !this._isChanging;
+  },
+
   getValue: function() {
     return this.props.value != null ? this.props.value : this.state.value;
   },
@@ -118,7 +123,9 @@ var ReactDOMTextarea = ReactCompositeComponent.createClass({
   handleChange: ReactCompositeComponent.autoBind(function(event) {
     var returnValue;
     if (this.props.onChange) {
+      this._isChanging = true;
       returnValue = this.props.onChange(event);
+      this._isChanging = false;
     }
     this.setState({value: event.target.value});
     return returnValue;

From dd614390614426d7011442d07900eb40c0753bce Mon Sep 17 00:00:00 2001
From: CommitSyncScript <jeffmo@fb.com>
Date: Mon, 1 Jul 2013 12:59:49 -0700
Subject: [PATCH 92/94] Revert Flattening of Children

I still think the semantics of flattening children is valid but we'll
want to revert the flattening implementation while we solidify the
semantics and try another approach.

This reverts flattening so that this.props.children can once again be
either a single child, flat array or nested array.

mapChildren calls flattenChildren before doing anything else. This is
not the most efficient approach but I wanted to keep this inital diff
simple. It also ignores empty values for backwards compatibility.

We may want to try another approach where empty values are included
in the map.

Validation of keys is still done inside ReactComponent. Ideally I'd
like to extract that into a separate module but to avoid cyclic
dependencies, I'm keeping it in ReactComponent for now.
---
 src/core/ReactComponent.js                    | 244 +++++++-----------
 src/core/ReactCompositeComponent.js           |   3 -
 src/core/ReactCurrentOwner.js                 |  14 +-
 .../ReactComponentFlattenChildren-test.js     | 160 ------------
 src/core/__tests__/ReactIdentity-test.js      |  44 ++--
 .../ReactMultiChildReconcile-test.js          |   5 +-
 src/utils/__tests__/mapChildren-test.js       |  26 +-
 src/utils/flattenChildren.js                  |  18 +-
 src/utils/mapChildren.js                      |  24 +-
 src/utils/onlyChild.js                        |  16 +-
 10 files changed, 155 insertions(+), 399 deletions(-)
 delete mode 100644 src/core/__tests__/ReactComponentFlattenChildren-test.js

diff --git a/src/core/ReactComponent.js b/src/core/ReactComponent.js
index addad00ab5..3f2ed6aff4 100644
--- a/src/core/ReactComponent.js
+++ b/src/core/ReactComponent.js
@@ -37,6 +37,12 @@ var merge = require('merge');
  */
 var OWNER = '{owner}';
 
+/**
+ * Props key that determines if a component's key was already validated.
+ * @private
+ */
+var IS_KEY_VALIDATED = '{is.key.validated}';
+
 /**
  * Every React component is in one of these life cycles.
  */
@@ -57,124 +63,70 @@ var ComponentLifeCycle = keyMirror({
  * This allows us to keep track of children between updates.
  */
 
-var CHILD_HAS_NO_IDENTITY =
-  'Each child in an array should have a unique "key" prop. ' +
-  'Check the render method of ';
-
-var CHILD_CAME_FROM_ANOTHER_OWNER = '. It was passed a child from ';
-
 var ownerHasWarned = {};
 
 /**
- * Helpers for flattening child arguments onto a new array or use an existing
- * one.
- */
-
-/**
- * Generate a unique key that identifies this child within a set.
+ * Warn if the component doesn't have an explicit key assigned to it.
+ * This component is in an array. The array could grow and shrink or be
+ * reordered. All children, that hasn't already been validated, are required to
+ * have a "key" property assigned to it.
  *
- * @param {*} Manually provided key.
- * @param {number} Index that is used if a manual key is not provided.
- * @param {?number} Grouping index if this is used in a nested array.
- * @return {string}
+ * @internal
+ * @param {ReactComponent} component Component that requires a key.
  */
-function createKey(explicitKey, childIndex, groupingIndex) {
-  return ReactCurrentOwner.getDepth() + ':' +
-         (groupingIndex == null ? '' : groupingIndex + ':') +
-         (explicitKey == null ? '' + childIndex : explicitKey);
+function validateExplicitKey(component) {
+  if (component[IS_KEY_VALIDATED] || component.props.key != null) {
+    return;
+  }
+  component[IS_KEY_VALIDATED] = true;
+
+  // We can't provide friendly warnings for top level components.
+  if (!ReactCurrentOwner.current) {
+    return;
+  }
+
+  // Name of the component whose render method tried to pass children.
+  var currentName = ReactCurrentOwner.current.constructor.displayName;
+  if (ownerHasWarned.hasOwnProperty(currentName)) {
+    return;
+  }
+  ownerHasWarned[currentName] = true;
+
+  var message = 'Each child in an array should have a unique "key" prop. ' +
+                'Check the render method of ' + currentName + '.';
+  if (!component.isOwnedBy(ReactCurrentOwner.current)) {
+    // Name of the component that originally created this child.
+    var childOwnerName =
+      component.props[OWNER] && component.props[OWNER].constructor.displayName;
+
+    // Usually the current owner is the offender, but if it accepts
+    // children as a property, it may be the creator of the child that's
+    // responsible for assigning it a key.
+    message += ' It was passed a child from ' + childOwnerName + '.';
+  }
+
+  global.console && console.warn && console.warn(message);
 }
 
 /**
- * Returns true if this parameter type is considered an empty child slot.
- * Used to filter out empty slots and generate a compact array.
+ * 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.
  *
- * @param {*} Child component or any value.
+ * @internal
+ * @param {*} component Statically passed child of any type.
  * @return {boolean}
  */
-function isEmptyChild(child) {
-  return child == null || typeof child === 'boolean';
-}
-
-/**
- * Assign an internal identity to a child component.
- *
- * @param {number} Index of the current array grouping.
- * @param {*} Child component or any value.
- * @param {number} Index of the current child within it's grouping.
- */
-function assignKey(groupingIndex, child, index) {
-  // Only truthy internal keys are valid. If it's not, we assign one.
-  if (ReactComponent.isValidComponent(child) && !child._key) {
-    var key = child.props.key;
-    if (__DEV__) {
-      // This is in an array. This could grow and shrink or be reordered.
-      // All children that doesn't already have autogenerated identity needs
-      // to have an explicit key provided.
-      if (key == null) {
-        // Name of the component whose render method tried to pass children.
-        var currentName =
-          ReactCurrentOwner.current &&
-          ReactCurrentOwner.current.constructor.displayName;
-
-        // Name of the component that originally created this child.
-        var childOwnerName =
-          child.props[OWNER] && child.props[OWNER].constructor.displayName;
-
-        if (currentName && !ownerHasWarned.hasOwnProperty(currentName)) {
-          ownerHasWarned[currentName] = true;
-          var message = CHILD_HAS_NO_IDENTITY + currentName;
-          if (childOwnerName && currentName !== childOwnerName) {
-            // Usually the current owner is the offender, but if it accepts
-            // children as a property, it may be the creator of the child that's
-            // responsible for assigning it a key.
-            message += CHILD_CAME_FROM_ANOTHER_OWNER + childOwnerName;
-          }
-          message += '.';
-          console && console.warn && console.warn(message);
-        }
+function validateChildKeys(component) {
+  if (Array.isArray(component)) {
+    for (var i = 0; i < component.length; i++) {
+      var child = component[i];
+      if (ReactComponent.isValidComponent(child)) {
+        validateExplicitKey(child);
       }
     }
-    child._key = createKey(key, index, groupingIndex);
-  }
-}
-
-/**
- * Make sure all children have an internal identity. Returns true if this is
- * already a compact array.
- *
- * @param {array} Children of any type.
- * @return {boolean}
- */
-function tryToReuseArray(children) {
-  for (var i = 0; i < children.length; i++) {
-    var child = children[i];
-    if (isEmptyChild(child)) {
-      return false;
-    }
-    assignKey(0, child, i);
-  }
-  return true;
-}
-
-/**
- * Append children from the source array to the target array. Make sure all
- * children have an internal identity assigned to it based on insertion point.
- *
- * @param {number} Index of the current array grouping.
- * @param {array} Source array.
- * @param {array} Target array that will be appended to.
- */
-function appendNestedChildren(groupingIndex, sourceArray, targetArray) {
-  for (var i = 0; i < sourceArray.length; i++) {
-    var child = sourceArray[i];
-    if (isEmptyChild(child)) {
-      continue;
-    }
-    assignKey(groupingIndex, child, i);
-    // TODO: Invalid components like strings could possibly need
-    // keys assigned to them here. Usually they're not stateful but
-    // CSS transitions and special events could make them stateful.
-    targetArray.push(child);
+  } else if (ReactComponent.isValidComponent(component)) {
+    // This component was passed in a valid location.
+    component[IS_KEY_VALIDATED] = true;
   }
 }
 
@@ -218,6 +170,23 @@ var ReactComponent = {
     );
   },
 
+  /**
+   * Generate a key string that identifies a component within a set.
+   *
+   * @param {*} component A component that could contain a manual key.
+   * @param {number} index Index that is used if a manual key is not provided.
+   * @return {string}
+   * @internal
+   */
+  getKey: function(component, index) {
+    if (component && component.props && component.props.key != null) {
+      // Explicit key
+      return '' + component.props.key;
+    }
+    // Implicit key determined by the index in the set
+    return '' + index;
+  },
+
   /**
    * @internal
    */
@@ -337,60 +306,23 @@ var ReactComponent = {
       // All components start unmounted.
       this._lifeCycleState = ComponentLifeCycle.UNMOUNTED;
 
-      // Children can be either an array or more than one argument
-      if (arguments.length < 2) {
-        return;
-      }
-
-      if (arguments.length === 2) {
-
-        // A single string or number child is treated as content, not an array.
-        var type = typeof children;
-        if (children == null || type === 'string' || type === 'number') {
-          this.props.children = children;
-          return;
+      // Children can be more than one argument
+      var childrenLength = arguments.length - 1;
+      if (childrenLength === 1) {
+        if (__DEV__) {
+          validateChildKeys(children);
         }
-
-        // A single array can be reused if it's already flat
-        if (Array.isArray(children) && tryToReuseArray(children)) {
-          this.props.children = children;
-          return;
+        this.props.children = children;
+      } else if (childrenLength > 1) {
+        var childArray = Array(childrenLength);
+        for (var i = 0; i < childrenLength; i++) {
+          if (__DEV__) {
+            validateChildKeys(arguments[i + 1]);
+          }
+          childArray[i] = arguments[i + 1];
         }
-
+        this.props.children = childArray;
       }
-
-      // Subsequent arguments are rolled into one child array. Array arguments
-      // are flattened onto it. This is inlined to avoid extra heap allocation.
-      var targetArray = null;
-      for (var i = 1; i < arguments.length; i++) {
-        var child = arguments[i];
-        if (Array.isArray(child)) {
-          if (child.length === 0) {
-            continue;
-          }
-
-          if (targetArray === null) {
-            targetArray = [];
-          }
-          appendNestedChildren(i - 1, child, targetArray);
-
-        } else if (!isEmptyChild(child)) {
-
-          // Only truthy internal keys are valid. If it's not, we assign one.
-          if (ReactComponent.isValidComponent(child) && !child._key) {
-            // This is a static node and therefore safe to key by index.
-            // No warning necessary.
-            child._key = createKey(child.props.key, i - 1);
-          }
-
-          if (targetArray === null) {
-            targetArray = [];
-          }
-          targetArray.push(child);
-
-        }
-      }
-      this.props.children = targetArray;
     },
 
     /**
diff --git a/src/core/ReactCompositeComponent.js b/src/core/ReactCompositeComponent.js
index be911dc6f8..e7fef2733b 100644
--- a/src/core/ReactCompositeComponent.js
+++ b/src/core/ReactCompositeComponent.js
@@ -472,7 +472,6 @@ var ReactCompositeComponentMixin = {
     this.state = null;
     this._pendingState = null;
     this._compositeLifeCycleState = null;
-    this._compositionLevel = ReactCurrentOwner.getDepth() + 1;
   },
 
   /**
@@ -521,8 +520,6 @@ var ReactCompositeComponentMixin = {
 
     this._renderedComponent = this._renderValidatedComponent();
 
-    this._renderedComponent._compositionLevel = this._compositionLevel + 1;
-
     // Done with mounting, `setState` will now trigger UI changes.
     this._compositeLifeCycleState = null;
     var markup = this._renderedComponent.mountComponent(rootID, transaction);
diff --git a/src/core/ReactCurrentOwner.js b/src/core/ReactCurrentOwner.js
index 9ac0ab6ede..ad137cdf2e 100644
--- a/src/core/ReactCurrentOwner.js
+++ b/src/core/ReactCurrentOwner.js
@@ -32,19 +32,7 @@ var ReactCurrentOwner = {
    * @internal
    * @type {ReactComponent}
    */
-  current: null,
-
-  /**
-   * @internal
-   * @return {number}
-   */
-  getDepth: function() {
-    var owner = ReactCurrentOwner.current;
-    if (!owner) {
-      return 0;
-    }
-    return owner._compositionLevel;
-  }
+  current: null
 
 };
 
diff --git a/src/core/__tests__/ReactComponentFlattenChildren-test.js b/src/core/__tests__/ReactComponentFlattenChildren-test.js
deleted file mode 100644
index 9ebe7baa2a..0000000000
--- a/src/core/__tests__/ReactComponentFlattenChildren-test.js
+++ /dev/null
@@ -1,160 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @jsx React.DOM
- * @emails react-core
- */
-
-"use strict";
-
-var React;
-
-var Fake;
-
-var singleChild = function(children) {
-  return (<Fake>{children}</Fake>).props.children;
-};
-
-var multiChild = function(child1, child2, child3, child4) {
-  return (<Fake>{child1} {child2} {child3}{child4}</Fake>).props.children;
-};
-
-
-describe('ReactComponentFlatten', function() {
-  beforeEach(function() {
-    require('mock-modules').dumpCache();
-    React = require('React');
-    var ReactComponent = require('ReactComponent');
-    var copyProperties = require('copyProperties');
-    var Constructor = function() {};
-    copyProperties(Constructor.prototype, ReactComponent.Mixin);
-    Fake = function() {
-      var instance = new Constructor();
-      instance.construct.apply(instance, arguments);
-      return instance;
-    };
-  });
-
-  it("should reuse a flat array", function() {
-    var children = [
-      <div key="foo" />,
-      <div key="bar" />
-    ];
-
-    var flat = singleChild(children);
-
-    expect(flat).toBe(children);
-    expect(flat[0]._key).toEqual('0:0:foo');
-    expect(flat[1]._key).toEqual('0:0:bar');
-  });
-
-  it("should collapse a sparse array", function() {
-    var children = [
-      null,
-      <div key="foo" />,
-      <div key="bar" />
-    ];
-
-    var flat = singleChild(children);
-
-    expect(flat).not.toBe(children);
-    expect(flat.length).toEqual(2);
-    expect(flat[0]._key).toEqual('0:0:foo');
-    expect(flat[1]._key).toEqual('0:0:bar');
-  });
-
-  it("should collapse a nested array into a flat array", function() {
-    var flat = multiChild(
-      null,
-      <div key="foo" />,
-      [<div key="bar" />, null]
-    );
-
-    expect(flat.length).toEqual(2);
-    expect(flat[0]._key).toEqual('0:foo');
-    expect(flat[1]._key).toEqual('0:2:bar');
-  });
-
-  it("should retain key index despite static empty values", function() {
-    var before = multiChild(
-      <div />,
-      <div />,
-      [<div key="foo" />],
-      [<div key="foo" />]
-    );
-
-    var after = multiChild(
-      null,
-      <div />,
-      null,
-      [<div key="foo" />]
-    );
-
-    expect(before.length).toEqual(4);
-    expect(after.length).toEqual(2);
-    expect(before[1]._key).toEqual(after[0]._key);
-    expect(before[3]._key).toEqual(after[1]._key);
-  });
-
-  it("should retain key index when wrapped", function() {
-    var before = singleChild(multiChild(
-      <div />,
-      <div />,
-      [<div key="foo" />],
-      [<div key="foo" />]
-    ));
-
-    var after = singleChild(multiChild(
-      null,
-      <div />,
-      null,
-      [<div key="foo" />]
-    ));
-
-    expect(before.length).toEqual(4);
-    expect(after.length).toEqual(2);
-    expect(before[1]._key).toEqual(after[0]._key);
-    expect(before[3]._key).toEqual(after[1]._key);
-  });
-
-  it("should assign idempotent strings through flattening", function() {
-    var children = [
-      'FOO',
-      'BAR'
-    ];
-    var flat = singleChild(children);
-    var wrappedFlat = multiChild(null, flat);
-    expect(flat).toBe(children);
-    expect(wrappedFlat.length).toBe(2);
-    expect(wrappedFlat[0]).toBe(flat[0]);
-    expect(wrappedFlat[1]).toBe(flat[1]);
-  });
-
-  it("cannot keep keys unique when children are unboxed", function() {
-    // This is a case that difficult to solve and should not actually be solved.
-    var children1 = [<div key="foo" />];
-    var children2 = [<div key="foo" />];
-    var flat1 = singleChild(children1);
-    var flat2 = singleChild(children2);
-    // There's no way to tell flat1[0] and flat2[0] apart.
-    var mergedChildren = [flat1[0], flat2[0]];
-    var newChildren = multiChild(mergedChildren);
-    expect(newChildren.length).toBe(2);
-    expect(newChildren[0]._key).toBe(newChildren[1]._key);
-  });
-
-});
-
-
diff --git a/src/core/__tests__/ReactIdentity-test.js b/src/core/__tests__/ReactIdentity-test.js
index 9d638d5579..fac5cde23d 100644
--- a/src/core/__tests__/ReactIdentity-test.js
+++ b/src/core/__tests__/ReactIdentity-test.js
@@ -55,8 +55,8 @@ describe('ReactIdentity', function() {
     React.renderComponent(instance, document.createElement('div'));
     var node = instance.getDOMNode();
     reactComponentExpect(instance).toBeDOMComponentWithChildCount(2);
-    checkId(node.childNodes[0], '.r[0].[0]{first}');
-    checkId(node.childNodes[1], '.r[0].[0]{second}');
+    checkId(node.childNodes[0], '.r[0].{first}');
+    checkId(node.childNodes[1], '.r[0].{second}');
   });
 
   it('should allow key property to express identity', function() {
@@ -71,10 +71,10 @@ describe('ReactIdentity', function() {
     React.renderComponent(instance, document.createElement('div'));
     var node = instance.getDOMNode();
     reactComponentExpect(instance).toBeDOMComponentWithChildCount(4);
-    checkId(node.childNodes[0], '.r[0].[0:apple]');
-    checkId(node.childNodes[1], '.r[0].[0:banana]');
-    checkId(node.childNodes[2], '.r[0].[0:0]');
-    checkId(node.childNodes[3], '.r[0].[0:123]');
+    checkId(node.childNodes[0], '.r[0].[apple]');
+    checkId(node.childNodes[1], '.r[0].[banana]');
+    checkId(node.childNodes[2], '.r[0].[0]');
+    checkId(node.childNodes[3], '.r[0].[123]');
   });
 
   it('should use instance identity', function() {
@@ -95,15 +95,13 @@ describe('ReactIdentity', function() {
     React.renderComponent(instance, document.createElement('div'));
     var node = instance.getDOMNode();
     reactComponentExpect(instance).toBeDOMComponentWithChildCount(3);
-    checkId(node.childNodes[0], '.r[0].[0:wrap1]');
-    checkId(
-      node.childNodes[0].firstChild,
-      '.r[0].[0:wrap1].[0:squirrel]'
-    );
-    checkId(node.childNodes[1], '.r[0].[0:wrap2]');
-    checkId(node.childNodes[1].firstChild, '.r[0].[0:wrap2].[0:bunny]');
-    checkId(node.childNodes[2], '.r[0].[0:2]');
-    checkId(node.childNodes[2].firstChild, '.r[0].[0:2].[0:chipmunk]');
+
+    checkId(node.childNodes[0], '.r[0].[wrap1]');
+    checkId(node.childNodes[0].firstChild, '.r[0].[wrap1].[squirrel]');
+    checkId(node.childNodes[1], '.r[0].[wrap2]');
+    checkId(node.childNodes[1].firstChild, '.r[0].[wrap2].[bunny]');
+    checkId(node.childNodes[2], '.r[0].[2]');
+    checkId(node.childNodes[2].firstChild, '.r[0].[2].[chipmunk]');
   });
 
   function renderAComponentWithKeyIntoContainer(key, container) {
@@ -118,7 +116,7 @@ describe('ReactIdentity', function() {
     expect(span1.getDOMNode()).not.toBe(null);
     expect(span2.getDOMNode()).not.toBe(null);
 
-    checkId(span1.getDOMNode(), '.r[0].[0:0:' + key + ']');
+    checkId(span1.getDOMNode(), '.r[0].[' + key + ']');
     checkId(span2.getDOMNode(), '.r[0].[1]{' + key + '}');
   }
 
@@ -247,7 +245,7 @@ describe('ReactIdentity', function() {
     }).not.toThrow();
   });
 
-  it('should retain keys during updates in composite components', function() {
+  it('should retain key during updates in composite components', function() {
 
     var TestComponent = React.createClass({
       render: function() {
@@ -283,19 +281,13 @@ describe('ReactIdentity', function() {
 
     React.renderComponent(wrapped, document.createElement('div'));
 
-    var beforeKey = wrapped
-      ._renderedComponent
-      ._renderedComponent
-      .props.children[0]._key;
+    var beforeID = ReactID.getID(wrapped.getDOMNode().firstChild);
 
     wrapped.swap();
 
-    var afterKey = wrapped
-      ._renderedComponent
-      ._renderedComponent
-      .props.children[0]._key;
+    var afterID = ReactID.getID(wrapped.getDOMNode().firstChild);
 
-    expect(beforeKey).not.toEqual(afterKey);
+    expect(beforeID).not.toEqual(afterID);
 
   });
 
diff --git a/src/core/__tests__/ReactMultiChildReconcile-test.js b/src/core/__tests__/ReactMultiChildReconcile-test.js
index 81b680c35b..0ff3cf2eab 100644
--- a/src/core/__tests__/ReactMultiChildReconcile-test.js
+++ b/src/core/__tests__/ReactMultiChildReconcile-test.js
@@ -42,12 +42,11 @@ var stripEmptyValues = function(obj) {
 };
 
 /**
- * These children are wrapped in an array and therefore their keys are prefixed.
- * Their name is also wrapped in an prefix and suffix character. We strip those
+ * Child names is are wrapped in an prefix and suffix character. We strip those
  * out. This relies on a tiny implementation detail of the rendering system.
  */
 var getOriginalKey = function(childName) {
-  return childName.substr(4, childName.length - 5);
+  return childName.substr(1, childName.length - 2);
 };
 
 /**
diff --git a/src/utils/__tests__/mapChildren-test.js b/src/utils/__tests__/mapChildren-test.js
index 3e1d3ca236..3f34482b09 100644
--- a/src/utils/__tests__/mapChildren-test.js
+++ b/src/utils/__tests__/mapChildren-test.js
@@ -48,11 +48,17 @@ describe('mapChildren', function() {
 
     this.addMatchers({
       toHaveKeys: function(expected) {
+        if (!Array.isArray(this.actual)) {
+          if (expected.length !== 1) {
+            return false;
+          }
+          return this.actual.props.key === expected[0];
+        }
         if (this.actual.length != expected.length) {
           return false;
         }
         return this.actual.every(function(component, index) {
-          return component._key === expected[index];
+          return component.props.key === expected[index];
         }, this);
       }
     });
@@ -73,9 +79,9 @@ describe('mapChildren', function() {
       .expectRenderedChild()
       .instance();
 
-    expect(mapFn).toHaveBeenCalledWith(simpleKid, '0:simple', 0);
+    expect(mapFn).toHaveBeenCalledWith(simpleKid, '[simple]', 0);
     expect(rendered.props.children[0]).toBe(simpleKid);
-    expect(rendered.props.children).toHaveKeys(['0:simple']);
+    expect(rendered.props.children).toHaveKeys(['[simple]']);
   });
 
   it('should pass key to returned component', function() {
@@ -93,10 +99,10 @@ describe('mapChildren', function() {
       .instance();
 
     expect(rendered.props.children[0]).not.toBe(simpleKid);
-    expect(rendered.props.children[0].props.children[0]).toBe(simpleKid);
-    expect(rendered.props.children).toHaveKeys(['1:0:0:simple']);
+    expect(rendered.props.children[0].props.children).toBe(simpleKid);
+    expect(rendered.props.children).toHaveKeys(['[simple]']);
     expect(rendered.props.children[0].props.children)
-      .toHaveKeys(['0:simple']);
+      .toHaveKeys(['simple']);
   });
 
   it('should be called for each child', function() {
@@ -123,12 +129,12 @@ describe('mapChildren', function() {
       .instance();
 
     expect(mapFn.calls.length).toBe(3);
-    expect(mapFn).toHaveBeenCalledWith(kidOne, '0:one', 0);
-    expect(mapFn).toHaveBeenCalledWith(kidTwo, '0:two', 1);
-    expect(mapFn).toHaveBeenCalledWith(kidThree, '0:three', 2);
+    expect(mapFn).toHaveBeenCalledWith(kidOne, '[one]', 0);
+    expect(mapFn).toHaveBeenCalledWith(kidTwo, '[two]', 1);
+    expect(mapFn).toHaveBeenCalledWith(kidThree, '[three]', 2);
     expect(rendered.props.children).not.toEqual(instance.props.children);
     expect(rendered.props.children).toHaveKeys([
-      '1:0:0:one', '1:0:0:two', '1:0:0:three'
+      '[one]', '[two]', '[three]'
     ]);
   });
 });
diff --git a/src/utils/flattenChildren.js b/src/utils/flattenChildren.js
index 7f18ab2fbd..a0e65d2137 100644
--- a/src/utils/flattenChildren.js
+++ b/src/utils/flattenChildren.js
@@ -18,6 +18,7 @@
 
 "use strict";
 
+var ReactComponent = require('ReactComponent');
 var ReactTextComponent = require('ReactTextComponent');
 
 var throwIf = require('throwIf');
@@ -39,27 +40,24 @@ var DUPLICATE_KEY_ERROR =
     'You have two children with identical keys. Make sure that you set the ' +
     '"key" property to a unique value such as a row ID.';
 
-/**
- * If there is only a single child, it still needs a name.
- */
-var ONLY_CHILD_NAME = '0';
-
 var flattenChildrenImpl = function(res, children, nameSoFar) {
-  var key;
   if (Array.isArray(children)) {
     for (var i = 0; i < children.length; i++) {
       var child = children[i];
-      key = child && (child._key || (child.props && child.props.key));
       flattenChildrenImpl(
         res,
         child,
-        nameSoFar + '[' + (key ? key : ('' + i)) + ']'
+        nameSoFar + '[' + ReactComponent.getKey(child, i) + ']'
       );
     }
   } else {
     var type = typeof children;
     var isOnlyChild = nameSoFar === '';
-    var storageName = isOnlyChild ? ONLY_CHILD_NAME : nameSoFar;
+    // If it's the only child, treat the name as if it was wrapped in an array
+    // so that it's consistent if the number of children grows
+    var storageName = isOnlyChild ?
+                      '[' + ReactComponent.getKey(children, 0) + ']' :
+                      nameSoFar;
     if (children === null || children === undefined || type === 'boolean') {
       res[storageName] = null;
     } else if (children.mountComponentIntoNode) {
@@ -71,7 +69,7 @@ var flattenChildrenImpl = function(res, children, nameSoFar) {
     } else {
       if (type === 'object') {
         throwIf(children && children.nodeType === 1, INVALID_CHILD);
-        for (key in children) {
+        for (var key in children) {
           if (children.hasOwnProperty(key)) {
             flattenChildrenImpl(
               res,
diff --git a/src/utils/mapChildren.js b/src/utils/mapChildren.js
index a357eefa06..fbdfd0cb11 100644
--- a/src/utils/mapChildren.js
+++ b/src/utils/mapChildren.js
@@ -18,14 +18,14 @@
 
 "use strict";
 
+var flattenChildren = require('flattenChildren');
+
 /**
  * Maps children that are typically specified as `props.children`.
  *
  * The provided mapFunction(child, key, index) will be called for each
  * leaf child.
  *
- * Note: mapChildren assumes children have already been flattened.
- *
  * @param {array} children
  * @param {function(*, string, int)} mapFunction
  * @param {*} context
@@ -36,12 +36,20 @@ function mapChildren(children, mapFunction, context) {
     return children;
   }
   var mappedChildren = [];
-  for (var ii = 0; ii < children.length; ii++) {
-    var child = children[ii];
-    var key = child._key;
-    var mappedChild = mapFunction.call(context, child, key, ii);
-    mappedChild.props.key = key;
-    mappedChildren.push(mappedChild);
+  var flattenedMap = flattenChildren(children);
+  var ii = 0;
+  for (var key in flattenedMap) {
+    if (!flattenedMap.hasOwnProperty(key)) {
+      continue;
+    }
+    var child = flattenedMap[key];
+    // In this version of map children we ignore empty children.
+    if (child !== null) {
+      var mappedChild = mapFunction.call(context, child, key, ii);
+      mappedChild.props.key = key;
+      mappedChildren.push(mappedChild);
+      ii++;
+    }
   }
   return mappedChildren;
 }
diff --git a/src/utils/onlyChild.js b/src/utils/onlyChild.js
index 2a78dcbfda..ccc5137668 100644
--- a/src/utils/onlyChild.js
+++ b/src/utils/onlyChild.js
@@ -24,24 +24,20 @@ var invariant = require('invariant');
 /**
  * Returns the first child in a collection of children and verifies that there
  * is only one child in the collection. The current implementation of this
- * function assumes that children have been flattened, but the purpose of this
- * helper function is to abstract away the particular structure of children.
+ * function assumes that a single child gets passed without a wrapper, but the
+ * purpose of this helper function is to abstract away the particular structure
+ * of children.
  *
  * @param {?object} children Child collection structure.
  * @return {ReactComponent} The first and only `ReactComponent` contained in the
  * structure.
  */
 function onlyChild(children) {
-  invariant(Array.isArray(children), 'onlyChild must be passed a valid Array.');
   invariant(
-    children.length === 1,
-    'onlyChild must be passed an Array with exactly one child.'
+    ReactComponent.isValidComponent(children),
+    'onlyChild must be passed a children with exactly one child.'
   );
-  invariant(
-    ReactComponent.isValidComponent(children[0]),
-    'onlyChild must be passed an Array with exactly one child.'
-  );
-  return children[0];
+  return children;
 }
 
 module.exports = onlyChild;

From e748be32da843211e68e60e3ec247bbfeef1d33a Mon Sep 17 00:00:00 2001
From: Ben Newman <bn@cs.stanford.edu>
Date: Mon, 1 Jul 2013 16:29:56 -0400
Subject: [PATCH 93/94] Bump Commoner version to fix EMFILE errors.

Finally found a more robust solution for the "too many open files"
problem: https://github.com/benjamn/commoner/commit/ad72ba42db.

Closes #137.
Closes #138.
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index e531b0e7c3..d85eb0a0d7 100644
--- a/package.json
+++ b/package.json
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "base62": "~0.1.1",
-    "commoner": "~0.7.0",
+    "commoner": "~0.7.1",
     "esprima": "https://github.com/facebook/esprima/tarball/a3e0ea3979eb8d54d8bfade220c272903f928b1e",
     "recast": "~0.4.8",
     "source-map": "~0.1.22"

From 18ef8962f1d1c8cf4d776a101e127a1ce8966c21 Mon Sep 17 00:00:00 2001
From: Ben Newman <bn@cs.stanford.edu>
Date: Mon, 1 Jul 2013 16:50:35 -0400
Subject: [PATCH 94/94] Bump Commoner version to disable dependency scanning by
 default.

If you are using bin/jsx independently, you may need to pass
--follow-requires to it if you rely on its dependency scanning.

Dependency scanning is still a good idea, but it's difficult to make it
work perfectly for everyone the first time they try bin/jsx.

Closes #131.
---
 grunt/tasks/jsx.js | 1 +
 package.json       | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/grunt/tasks/jsx.js b/grunt/tasks/jsx.js
index 7aa8407596..290816711f 100644
--- a/grunt/tasks/jsx.js
+++ b/grunt/tasks/jsx.js
@@ -11,6 +11,7 @@ module.exports = function() {
   var args = [
     "--cache-dir", ".module-cache",
     "--relativize",
+    "--follow-requires",
     config.sourceDir,
     config.outputDir
   ];
diff --git a/package.json b/package.json
index d85eb0a0d7..7eb7e57801 100644
--- a/package.json
+++ b/package.json
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "base62": "~0.1.1",
-    "commoner": "~0.7.1",
+    "commoner": "~0.8.0",
     "esprima": "https://github.com/facebook/esprima/tarball/a3e0ea3979eb8d54d8bfade220c272903f928b1e",
     "recast": "~0.4.8",
     "source-map": "~0.1.22"